mirror of
https://github.com/Orange-OpenSource/hurl.git
synced 2024-09-21 18:57:33 +03:00
Documents Reader and use idiomatic naming for methods.
This commit is contained in:
jcamiel
parent
28292ef114
commit
bd2a7f4e9a
@ -23,7 +23,7 @@ use super::reader::Reader;
|
||||
use super::ParseResult;
|
||||
|
||||
pub fn parse(s: &str) -> Result<Query, Error> {
|
||||
let mut reader = Reader::init(s);
|
||||
let mut reader = Reader::new(s);
|
||||
query(&mut reader)
|
||||
}
|
||||
|
||||
@ -296,15 +296,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_try_left_bracket() {
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = try_left_bracket(&mut reader).err().unwrap();
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("[xxx");
|
||||
let mut reader = Reader::new("[xxx");
|
||||
assert!(try_left_bracket(&mut reader).is_ok());
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init(".[xxx");
|
||||
let mut reader = Reader::new(".[xxx");
|
||||
assert!(try_left_bracket(&mut reader).is_ok());
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
}
|
||||
@ -314,26 +314,23 @@ mod tests {
|
||||
let expected_query = Query {
|
||||
selectors: vec![Selector::ArrayIndex(vec![2])],
|
||||
};
|
||||
assert_eq!(query(&mut Reader::init("$[2]")).unwrap(), expected_query);
|
||||
assert_eq!(query(&mut Reader::new("$[2]")).unwrap(), expected_query);
|
||||
|
||||
let expected_query = Query {
|
||||
selectors: vec![Selector::NameChild("key".to_string())],
|
||||
};
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$['key']")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
assert_eq!(query(&mut Reader::init("$.key")).unwrap(), expected_query);
|
||||
assert_eq!(query(&mut Reader::new("$['key']")).unwrap(), expected_query);
|
||||
assert_eq!(query(&mut Reader::new("$.key")).unwrap(), expected_query);
|
||||
|
||||
let expected_query = Query {
|
||||
selectors: vec![Selector::NameChild("profile-id".to_string())],
|
||||
};
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$['profile-id']")).unwrap(),
|
||||
query(&mut Reader::new("$['profile-id']")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$.profile-id")).unwrap(),
|
||||
query(&mut Reader::new("$.profile-id")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
|
||||
@ -346,11 +343,11 @@ mod tests {
|
||||
],
|
||||
};
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$.store.book[0].title")).unwrap(),
|
||||
query(&mut Reader::new("$.store.book[0].title")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$['store']['book'][0]['title']")).unwrap(),
|
||||
query(&mut Reader::new("$['store']['book'][0]['title']")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
|
||||
@ -361,24 +358,24 @@ mod tests {
|
||||
],
|
||||
};
|
||||
assert_eq!(
|
||||
query(&mut Reader::init("$..book[2]")).unwrap(),
|
||||
query(&mut Reader::new("$..book[2]")).unwrap(),
|
||||
expected_query
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn test_query_error() {
|
||||
let error = query(&mut Reader::init("?$.store")).err().unwrap();
|
||||
let error = query(&mut Reader::new("?$.store")).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
|
||||
let error = query(&mut Reader::init("$.store?")).err().unwrap();
|
||||
let error = query(&mut Reader::new("$.store?")).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 8 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_filter() {
|
||||
// Filter exist value
|
||||
let mut reader = Reader::init("[?(@.isbn)]");
|
||||
let mut reader = Reader::new("[?(@.isbn)]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::Filter(Predicate {
|
||||
@ -389,7 +386,7 @@ mod tests {
|
||||
assert_eq!(reader.state.cursor, 11);
|
||||
|
||||
// Filter equal on string with single quotes
|
||||
let mut reader = Reader::init("[?(@.key=='value')]");
|
||||
let mut reader = Reader::new("[?(@.key=='value')]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::Filter(Predicate {
|
||||
@ -399,7 +396,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 19);
|
||||
|
||||
let mut reader = Reader::init("[?(@.price<10)]");
|
||||
let mut reader = Reader::new("[?(@.price<10)]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::Filter(Predicate {
|
||||
@ -415,7 +412,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_recursive() {
|
||||
let mut reader = Reader::init("..book");
|
||||
let mut reader = Reader::new("..book");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::RecursiveKey("book".to_string())
|
||||
@ -425,14 +422,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_array_index() {
|
||||
let mut reader = Reader::init("[2]");
|
||||
let mut reader = Reader::new("[2]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::ArrayIndex(vec![2])
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("[0,1]");
|
||||
let mut reader = Reader::new("[0,1]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::ArrayIndex(vec![0, 1])
|
||||
@ -441,7 +438,7 @@ mod tests {
|
||||
|
||||
// you don't need to keep the exact string
|
||||
// this is not part of the AST
|
||||
let mut reader = Reader::init(".[2]");
|
||||
let mut reader = Reader::new(".[2]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::ArrayIndex(vec![2])
|
||||
@ -451,20 +448,20 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_wildcard() {
|
||||
let mut reader = Reader::init("[*]");
|
||||
let mut reader = Reader::new("[*]");
|
||||
assert_eq!(selector(&mut reader).unwrap(), Selector::ArrayWildcard {});
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
// you don't need to keep the exact string
|
||||
// this is not part of the AST
|
||||
let mut reader = Reader::init(".[*]");
|
||||
let mut reader = Reader::new(".[*]");
|
||||
assert_eq!(selector(&mut reader).unwrap(), Selector::ArrayWildcard {});
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_array_slice() {
|
||||
let mut reader = Reader::init("[-1:]");
|
||||
let mut reader = Reader::new("[-1:]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::ArraySlice(Slice {
|
||||
@ -474,7 +471,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("[:2]");
|
||||
let mut reader = Reader::new("[:2]");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::ArraySlice(Slice {
|
||||
@ -487,21 +484,21 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_key_bracket_selector() {
|
||||
let mut reader = Reader::init("['key']");
|
||||
let mut reader = Reader::new("['key']");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::NameChild("key".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 7);
|
||||
|
||||
let mut reader = Reader::init(".['key']");
|
||||
let mut reader = Reader::new(".['key']");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::NameChild("key".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 8);
|
||||
|
||||
let mut reader = Reader::init("['key1']");
|
||||
let mut reader = Reader::new("['key1']");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::NameChild("key1".to_string())
|
||||
@ -511,14 +508,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_selector_key_dot_notation() {
|
||||
let mut reader = Reader::init(".key");
|
||||
let mut reader = Reader::new(".key");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::NameChild("key".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init(".key1");
|
||||
let mut reader = Reader::new(".key1");
|
||||
assert_eq!(
|
||||
selector(&mut reader).unwrap(),
|
||||
Selector::NameChild("key1".to_string())
|
||||
@ -530,7 +527,7 @@ mod tests {
|
||||
pub fn test_predicate() {
|
||||
// Key exists
|
||||
assert_eq!(
|
||||
predicate(&mut Reader::init("@.isbn")).unwrap(),
|
||||
predicate(&mut Reader::new("@.isbn")).unwrap(),
|
||||
Predicate {
|
||||
key: vec!["isbn".to_string()],
|
||||
func: PredicateFunc::KeyExist {},
|
||||
@ -539,7 +536,7 @@ mod tests {
|
||||
|
||||
// Filter equal on string with single quotes
|
||||
assert_eq!(
|
||||
predicate(&mut Reader::init("@.key=='value'")).unwrap(),
|
||||
predicate(&mut Reader::new("@.key=='value'")).unwrap(),
|
||||
Predicate {
|
||||
key: vec!["key".to_string()],
|
||||
func: PredicateFunc::EqualString("value".to_string()),
|
||||
@ -548,7 +545,7 @@ mod tests {
|
||||
|
||||
// Filter equal on int
|
||||
assert_eq!(
|
||||
predicate(&mut Reader::init("@.key==1")).unwrap(),
|
||||
predicate(&mut Reader::new("@.key==1")).unwrap(),
|
||||
Predicate {
|
||||
key: vec!["key".to_string()],
|
||||
func: PredicateFunc::Equal(Number { int: 1, decimal: 0 }),
|
||||
@ -557,7 +554,7 @@ mod tests {
|
||||
|
||||
// Filter equal on int for key in object
|
||||
assert_eq!(
|
||||
predicate(&mut Reader::init("@.obj.key==1")).unwrap(),
|
||||
predicate(&mut Reader::new("@.obj.key==1")).unwrap(),
|
||||
Predicate {
|
||||
key: vec!["obj".to_string(), "key".to_string()],
|
||||
func: PredicateFunc::Equal(Number { int: 1, decimal: 0 }),
|
||||
@ -566,7 +563,7 @@ mod tests {
|
||||
|
||||
// Filter less than int
|
||||
assert_eq!(
|
||||
predicate(&mut Reader::init("@.price<10")).unwrap(),
|
||||
predicate(&mut Reader::new("@.price<10")).unwrap(),
|
||||
Predicate {
|
||||
key: vec!["price".to_string()],
|
||||
func: PredicateFunc::LessThan(Number {
|
||||
@ -579,14 +576,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_predicate_func() {
|
||||
let mut reader = Reader::init("==2");
|
||||
let mut reader = Reader::new("==2");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::Equal(Number { int: 2, decimal: 0 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("==2.1");
|
||||
let mut reader = Reader::new("==2.1");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::Equal(Number {
|
||||
@ -596,7 +593,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("== 2.1 ");
|
||||
let mut reader = Reader::new("== 2.1 ");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::Equal(Number {
|
||||
@ -606,35 +603,35 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 7);
|
||||
|
||||
let mut reader = Reader::init("=='hello'");
|
||||
let mut reader = Reader::new("=='hello'");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::EqualString("hello".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 9);
|
||||
|
||||
let mut reader = Reader::init(">5");
|
||||
let mut reader = Reader::new(">5");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::GreaterThan(Number { int: 5, decimal: 0 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init(">=5");
|
||||
let mut reader = Reader::new(">=5");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::GreaterThanOrEqual(Number { int: 5, decimal: 0 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("<5");
|
||||
let mut reader = Reader::new("<5");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::LessThan(Number { int: 5, decimal: 0 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("<=5");
|
||||
let mut reader = Reader::new("<=5");
|
||||
assert_eq!(
|
||||
predicate_func(&mut reader).unwrap(),
|
||||
PredicateFunc::LessThanOrEqual(Number { int: 5, decimal: 0 })
|
||||
|
||||
@ -252,22 +252,22 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_natural() {
|
||||
let mut reader = Reader::init("0");
|
||||
let mut reader = Reader::new("0");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 0);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("0.");
|
||||
let mut reader = Reader::new("0.");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 0);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("10x");
|
||||
let mut reader = Reader::new("10x");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 10);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_natural_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -278,7 +278,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("01");
|
||||
let mut reader = Reader::new("01");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert_eq!(
|
||||
@ -289,7 +289,7 @@ mod tests {
|
||||
);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -303,16 +303,16 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_integer() {
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), 1);
|
||||
|
||||
let mut reader = Reader::init("1.1");
|
||||
let mut reader = Reader::new("1.1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), 1);
|
||||
|
||||
let mut reader = Reader::init("-1.1");
|
||||
let mut reader = Reader::new("-1.1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), -1);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = integer(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -326,15 +326,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_number() {
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
assert_eq!(number(&mut reader).unwrap(), Number { int: 1, decimal: 0 });
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("1.0");
|
||||
let mut reader = Reader::new("1.0");
|
||||
assert_eq!(number(&mut reader).unwrap(), Number { int: 1, decimal: 0 });
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("-1.0");
|
||||
let mut reader = Reader::new("-1.0");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -344,7 +344,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("1.1");
|
||||
let mut reader = Reader::new("1.1");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -354,7 +354,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("1.100");
|
||||
let mut reader = Reader::new("1.100");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -364,7 +364,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("1.01");
|
||||
let mut reader = Reader::new("1.01");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -374,7 +374,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("1.010");
|
||||
let mut reader = Reader::new("1.010");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -384,7 +384,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("-0.333333333333333333");
|
||||
let mut reader = Reader::new("-0.333333333333333333");
|
||||
assert_eq!(
|
||||
number(&mut reader).unwrap(),
|
||||
Number {
|
||||
@ -397,7 +397,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_number_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = number(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -408,7 +408,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("-");
|
||||
let mut reader = Reader::new("-");
|
||||
let error = number(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -419,7 +419,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1.");
|
||||
let mut reader = Reader::new("1.");
|
||||
let error = number(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -430,7 +430,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 3 });
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1.x");
|
||||
let mut reader = Reader::new("1.x");
|
||||
let error = number(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -444,13 +444,13 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_string_value() {
|
||||
let mut reader = Reader::init("'hello'");
|
||||
let mut reader = Reader::new("'hello'");
|
||||
assert_eq!(string_value(&mut reader).unwrap(), "hello".to_string());
|
||||
|
||||
let mut reader = Reader::init("'\\''");
|
||||
let mut reader = Reader::new("'\\''");
|
||||
assert_eq!(string_value(&mut reader).unwrap(), "'".to_string());
|
||||
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
let error = string_value(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -461,7 +461,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("'hi");
|
||||
let mut reader = Reader::new("'hi");
|
||||
let error = string_value(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -475,13 +475,13 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_key_name() {
|
||||
let mut reader = Reader::init("id'");
|
||||
let mut reader = Reader::new("id'");
|
||||
assert_eq!(key_name(&mut reader).unwrap(), "id".to_string());
|
||||
|
||||
let mut reader = Reader::init("id123");
|
||||
let mut reader = Reader::new("id123");
|
||||
assert_eq!(key_name(&mut reader).unwrap(), "id123".to_string());
|
||||
|
||||
let mut reader = Reader::init(".");
|
||||
let mut reader = Reader::new(".");
|
||||
let error = key_name(&mut reader).err().unwrap();
|
||||
assert!(!error.recoverable);
|
||||
assert_eq!(
|
||||
@ -491,7 +491,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("1id");
|
||||
let mut reader = Reader::new("1id");
|
||||
let error = key_name(&mut reader).err().unwrap();
|
||||
assert!(!error.recoverable);
|
||||
assert_eq!(
|
||||
@ -504,10 +504,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_key_path() {
|
||||
let mut reader = Reader::init("id");
|
||||
let mut reader = Reader::new("id");
|
||||
assert_eq!(key_path(&mut reader).unwrap(), vec!["id".to_string()]);
|
||||
|
||||
let mut reader = Reader::init("key1.key2");
|
||||
let mut reader = Reader::new("key1.key2");
|
||||
assert_eq!(
|
||||
key_path(&mut reader).unwrap(),
|
||||
vec!["key1".to_string(), "key2".to_string()]
|
||||
@ -516,15 +516,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_literal() {
|
||||
let mut reader = Reader::init("hello");
|
||||
let mut reader = Reader::new("hello");
|
||||
assert_eq!(literal("hello", &mut reader), Ok(()));
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("hello ");
|
||||
let mut reader = Reader::new("hello ");
|
||||
assert_eq!(literal("hello", &mut reader), Ok(()));
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -535,7 +535,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -546,7 +546,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("he");
|
||||
let mut reader = Reader::new("he");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
|
||||
@ -15,8 +15,11 @@
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
use std::cmp::min;
|
||||
|
||||
use super::Pos;
|
||||
|
||||
/// Represents a JSONPath reader.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Reader {
|
||||
pub buffer: Vec<char>,
|
||||
@ -30,7 +33,8 @@ pub struct ReaderState {
|
||||
}
|
||||
|
||||
impl Reader {
|
||||
pub fn init(s: &str) -> Reader {
|
||||
/// Creates a new reader.
|
||||
pub fn new(s: &str) -> Reader {
|
||||
Reader {
|
||||
buffer: s.chars().collect(),
|
||||
state: ReaderState {
|
||||
@ -40,10 +44,12 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the reader has read all the buffer, false otherwise.
|
||||
pub fn is_eof(&self) -> bool {
|
||||
self.state.cursor == self.buffer.len()
|
||||
}
|
||||
|
||||
/// Returns the next char from the buffer advancing the internal state.
|
||||
pub fn read(&mut self) -> Option<char> {
|
||||
match self.buffer.get(self.state.cursor) {
|
||||
None => None,
|
||||
@ -61,10 +67,20 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn peek(&mut self) -> Option<char> {
|
||||
self.buffer.get(self.state.cursor).copied()
|
||||
/// Returns `count` chars from the buffer advancing the internal state.
|
||||
/// This methods can returns less than `count` chars if there is not enough chars in the buffer.
|
||||
pub fn read_n(&mut self, count: usize) -> String {
|
||||
let mut s = String::from("");
|
||||
for _ in 0..count {
|
||||
match self.read() {
|
||||
None => {}
|
||||
Some(c) => s.push(c),
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Returns chars from the buffer while `predicate` is true, advancing the internal state.
|
||||
pub fn read_while(&mut self, predicate: fn(&char) -> bool) -> String {
|
||||
let mut s = String::from("");
|
||||
loop {
|
||||
@ -81,32 +97,27 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
// assume that you still have count characters to read in your buffer
|
||||
pub fn read_n(&mut self, count: usize) -> String {
|
||||
let mut s = String::from("");
|
||||
for _ in 0..count {
|
||||
match self.read() {
|
||||
None => {}
|
||||
Some(c) => s.push(c),
|
||||
}
|
||||
}
|
||||
s
|
||||
/// Returns the next char from the buffer without advancing the internal state.
|
||||
pub fn peek(&mut self) -> Option<char> {
|
||||
self.buffer.get(self.state.cursor).copied()
|
||||
}
|
||||
|
||||
/// Returns the `count` char from the buffer without advancing the internal state.
|
||||
/// This methods can returns less than `count` chars if there is not enough chars in the buffer.
|
||||
pub fn peek_n(&self, count: usize) -> String {
|
||||
let start = self.state.cursor;
|
||||
let end = min(start + count, self.buffer.len());
|
||||
self.buffer[start..end].iter().collect()
|
||||
}
|
||||
|
||||
pub fn try_literal(&mut self, value: &str) -> bool {
|
||||
if self.remaining().starts_with(value.to_string().as_str()) {
|
||||
if self.peek_n(value.len()) == value {
|
||||
self.read_n(value.len());
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub fn remaining(&self) -> String {
|
||||
self.buffer.as_slice()[self.state.cursor..self.buffer.len()]
|
||||
.iter()
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
fn is_combining_character(c: char) -> bool {
|
||||
@ -119,10 +130,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_reader() {
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
assert!(!reader.is_eof());
|
||||
assert_eq!(reader.remaining(), "hi".to_string());
|
||||
assert_eq!(reader.peek_n(2), "hi".to_string());
|
||||
|
||||
assert_eq!(reader.read().unwrap(), 'h');
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
@ -135,11 +146,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_try_predicate() {
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
assert!(reader.try_literal("hi"));
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("hello");
|
||||
let mut reader = Reader::new("hello");
|
||||
assert!(!reader.try_literal("hi"));
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
}
|
||||
|
||||
@ -69,7 +69,7 @@ pub fn eval_json_value(
|
||||
|
||||
// The String can only be null, a bool, a number
|
||||
// It will be easier when your variables value have a type
|
||||
let mut reader = Reader::init(s.as_str());
|
||||
let mut reader = Reader::new(s.as_str());
|
||||
let start = reader.state.clone();
|
||||
if parse_json_number(&mut reader).is_ok() {
|
||||
return Ok(s);
|
||||
|
||||
@ -181,27 +181,27 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_decode_one_block() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
assert_eq!(parse(&mut reader), vec![] as Vec<u8>);
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init("AA==;");
|
||||
let mut reader = Reader::new("AA==;");
|
||||
assert_eq!(parse(&mut reader), vec![0]);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("AA");
|
||||
let mut reader = Reader::new("AA");
|
||||
assert_eq!(parse(&mut reader), vec![0]);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("AA;");
|
||||
let mut reader = Reader::new("AA;");
|
||||
assert_eq!(parse(&mut reader), vec![0]);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("TWE=;");
|
||||
let mut reader = Reader::new("TWE=;");
|
||||
assert_eq!(parse(&mut reader), vec![77, 97]);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("TWFu;");
|
||||
let mut reader = Reader::new("TWFu;");
|
||||
assert_eq!(parse(&mut reader), vec![77, 97, 110]);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
}
|
||||
@ -222,29 +222,29 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_decode_with_padding() {
|
||||
let mut reader = Reader::init("YW55IGNhcm5hbCBwbGVhcw==;");
|
||||
let mut reader = Reader::new("YW55IGNhcm5hbCBwbGVhcw==;");
|
||||
let decoded = parse(&mut reader);
|
||||
assert_eq!(decoded, b"any carnal pleas");
|
||||
|
||||
let mut reader = Reader::init("YW55IGNhcm5hbCBwbGVhc3U=;");
|
||||
let mut reader = Reader::new("YW55IGNhcm5hbCBwbGVhc3U=;");
|
||||
assert_eq!(parse(&mut reader), b"any carnal pleasu");
|
||||
|
||||
let mut reader = Reader::init("YW55IGNhcm5hbCBwbGVhc3Vy;");
|
||||
let mut reader = Reader::new("YW55IGNhcm5hbCBwbGVhc3Vy;");
|
||||
assert_eq!(parse(&mut reader), b"any carnal pleasur");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_decode_without_padding() {
|
||||
let mut reader = Reader::init("YW55IGNhcm5hbCBwbGVhcw;");
|
||||
let mut reader = Reader::new("YW55IGNhcm5hbCBwbGVhcw;");
|
||||
assert_eq!(parse(&mut reader), b"any carnal pleas");
|
||||
|
||||
let mut reader = Reader::init("YW55IGNhcm5hbCBwbGVhc3U;");
|
||||
let mut reader = Reader::new("YW55IGNhcm5hbCBwbGVhc3U;");
|
||||
assert_eq!(parse(&mut reader), b"any carnal pleasu");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_decode_with_whitespace() {
|
||||
let mut reader = Reader::init("TW E=\n;");
|
||||
let mut reader = Reader::new("TW E=\n;");
|
||||
assert_eq!(parse(&mut reader), vec![77, 97]);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
}
|
||||
|
||||
@ -80,7 +80,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_json() {
|
||||
let mut reader = Reader::init("[1,2,3] ");
|
||||
let mut reader = Reader::new("[1,2,3] ");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::Json(JsonValue::List {
|
||||
@ -106,7 +106,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 7);
|
||||
|
||||
let mut reader = Reader::init("{ } ");
|
||||
let mut reader = Reader::new("{ } ");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::Json(JsonValue::Object {
|
||||
@ -116,14 +116,14 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::Json(JsonValue::Boolean(true))
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("\"\" x");
|
||||
let mut reader = Reader::new("\"\" x");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::Json(JsonValue::String(Template {
|
||||
@ -137,7 +137,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_xml() {
|
||||
let mut reader = Reader::init("<a/>");
|
||||
let mut reader = Reader::new("<a/>");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::Xml(String::from("<a/>"))
|
||||
@ -146,7 +146,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_json_error() {
|
||||
let mut reader = Reader::init("{ x ");
|
||||
let mut reader = Reader::new("{ x ");
|
||||
let error = bytes(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 3 });
|
||||
assert_eq!(
|
||||
@ -159,7 +159,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_multilines_error() {
|
||||
let mut reader = Reader::init("```\nxxx ");
|
||||
let mut reader = Reader::new("```\nxxx ");
|
||||
let error = bytes(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 4 });
|
||||
assert_eq!(error.inner, ParseError::Multiline);
|
||||
@ -167,7 +167,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_eof() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = bytes(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -180,7 +180,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_json_bytes() {
|
||||
let mut reader = Reader::init("100");
|
||||
let mut reader = Reader::new("100");
|
||||
assert_eq!(
|
||||
json_bytes(&mut reader).unwrap(),
|
||||
Bytes::Json(JsonValue::Number("100".to_string()))
|
||||
@ -189,7 +189,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_bytes_string() {
|
||||
let mut reader = Reader::init("`foo` ");
|
||||
let mut reader = Reader::new("`foo` ");
|
||||
assert_eq!(
|
||||
bytes(&mut reader).unwrap(),
|
||||
Bytes::OnelineString(Template {
|
||||
|
||||
@ -26,7 +26,7 @@ use crate::parser::ParseResult;
|
||||
pub fn cookiepath(reader: &mut Reader) -> ParseResult<'static, CookiePath> {
|
||||
let start = reader.state.pos.clone();
|
||||
let s = reader.read_while(|c| *c != '[');
|
||||
let mut template_reader = Reader::init(s.as_str());
|
||||
let mut template_reader = Reader::new(s.as_str());
|
||||
template_reader.state.pos = start;
|
||||
let name = unquoted_template(&mut template_reader)?;
|
||||
let attribute = optional(cookiepath_attribute, reader)?;
|
||||
@ -73,7 +73,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookiepath_simple() {
|
||||
let mut reader = Reader::init("cookie1");
|
||||
let mut reader = Reader::new("cookie1");
|
||||
assert_eq!(
|
||||
cookiepath(&mut reader).unwrap(),
|
||||
CookiePath {
|
||||
@ -93,7 +93,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookiepath_with_attribute() {
|
||||
let mut reader = Reader::init("cookie1[Domain]");
|
||||
let mut reader = Reader::new("cookie1[Domain]");
|
||||
assert_eq!(
|
||||
cookiepath(&mut reader).unwrap(),
|
||||
CookiePath {
|
||||
@ -123,7 +123,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookiepath_with_template() {
|
||||
let mut reader = Reader::init("{{name}}[Domain]");
|
||||
let mut reader = Reader::new("{{name}}[Domain]");
|
||||
assert_eq!(
|
||||
cookiepath(&mut reader).unwrap(),
|
||||
CookiePath {
|
||||
@ -163,13 +163,13 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookiepath_error() {
|
||||
let mut reader = Reader::init("cookie1[");
|
||||
let mut reader = Reader::new("cookie1[");
|
||||
let error = cookiepath(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 9 });
|
||||
assert_eq!(error.inner, ParseError::InvalidCookieAttribute {});
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("cookie1[{{field]");
|
||||
let mut reader = Reader::new("cookie1[{{field]");
|
||||
let error = cookiepath(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 9 });
|
||||
assert_eq!(error.inner, ParseError::InvalidCookieAttribute {});
|
||||
@ -178,21 +178,21 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookie_attribute_name() {
|
||||
let mut reader = Reader::init("Domain");
|
||||
let mut reader = Reader::new("Domain");
|
||||
assert_eq!(
|
||||
cookiepath_attribute_name(&mut reader).unwrap(),
|
||||
CookieAttributeName::Domain("Domain".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("domain");
|
||||
let mut reader = Reader::new("domain");
|
||||
assert_eq!(
|
||||
cookiepath_attribute_name(&mut reader).unwrap(),
|
||||
CookieAttributeName::Domain("domain".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("unknown");
|
||||
let mut reader = Reader::new("unknown");
|
||||
let error = cookiepath_attribute_name(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::InvalidCookieAttribute {});
|
||||
|
||||
@ -83,7 +83,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_expr() {
|
||||
let mut reader = Reader::init("{{ name}}");
|
||||
let mut reader = Reader::new("{{ name}}");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
Expr {
|
||||
@ -105,7 +105,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_expr_error() {
|
||||
let mut reader = Reader::init("{{host>}}");
|
||||
let mut reader = Reader::new("{{host>}}");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(
|
||||
@ -119,7 +119,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_expr_error_eof() {
|
||||
let mut reader = Reader::init("{{host");
|
||||
let mut reader = Reader::new("{{host");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(
|
||||
@ -133,7 +133,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_variable() {
|
||||
let mut reader = Reader::init("name");
|
||||
let mut reader = Reader::new("name");
|
||||
assert_eq!(
|
||||
variable_name(&mut reader).unwrap(),
|
||||
Variable {
|
||||
@ -142,7 +142,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("my-id");
|
||||
let mut reader = Reader::new("my-id");
|
||||
assert_eq!(
|
||||
variable_name(&mut reader).unwrap(),
|
||||
Variable {
|
||||
|
||||
@ -52,7 +52,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_filename() {
|
||||
let mut reader = Reader::init("data/data.bin");
|
||||
let mut reader = Reader::new("data/data.bin");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
Filename {
|
||||
@ -62,7 +62,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 13);
|
||||
|
||||
let mut reader = Reader::init("data.bin");
|
||||
let mut reader = Reader::new("data.bin");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
Filename {
|
||||
@ -75,7 +75,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_include_space() {
|
||||
let mut reader = Reader::init("file\\ with\\ spaces");
|
||||
let mut reader = Reader::new("file\\ with\\ spaces");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
Filename {
|
||||
@ -88,7 +88,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_filename_error() {
|
||||
let mut reader = Reader::init("???");
|
||||
let mut reader = Reader::new("???");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.inner, ParseError::Filename {});
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
|
||||
@ -183,7 +183,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_count() {
|
||||
let mut reader = Reader::init("count");
|
||||
let mut reader = Reader::new("count");
|
||||
assert_eq!(
|
||||
filter(&mut reader).unwrap(),
|
||||
Filter {
|
||||
@ -195,7 +195,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_error() {
|
||||
let mut reader = Reader::init("xcount");
|
||||
let mut reader = Reader::new("xcount");
|
||||
let err = filter(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
err.inner,
|
||||
@ -206,7 +206,7 @@ mod tests {
|
||||
assert_eq!(err.pos, Pos { line: 1, column: 1 });
|
||||
assert!(err.recoverable);
|
||||
|
||||
let mut reader = Reader::init("regex 1");
|
||||
let mut reader = Reader::new("regex 1");
|
||||
let err = filter(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
err.inner,
|
||||
|
||||
@ -87,7 +87,7 @@ fn string_template(reader: &mut Reader) -> ParseResult<'static, Template> {
|
||||
fn any_char(reader: &mut Reader) -> ParseResult<'static, (char, String, Pos)> {
|
||||
let start = reader.state.clone();
|
||||
match escape_char(reader) {
|
||||
Ok(c) => Ok((c, reader.from(start.cursor), start.pos)),
|
||||
Ok(c) => Ok((c, reader.peek_back(start.cursor), start.pos)),
|
||||
Err(e) => {
|
||||
if e.recoverable {
|
||||
reader.state = start.clone();
|
||||
@ -109,7 +109,7 @@ fn any_char(reader: &mut Reader) -> ParseResult<'static, (char, String, Pos)> {
|
||||
},
|
||||
})
|
||||
} else {
|
||||
Ok((c, reader.from(start.cursor), start.pos))
|
||||
Ok((c, reader.peek_back(start.cursor), start.pos))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -364,13 +364,13 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_parse_error() {
|
||||
let mut reader = Reader::init("{ \"a\":\n}");
|
||||
let mut reader = Reader::new("{ \"a\":\n}");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(error.inner, error::ParseError::Json {});
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("[0,1,]");
|
||||
let mut reader = Reader::new("[0,1,]");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 6 });
|
||||
assert_eq!(error.inner, error::ParseError::Json {});
|
||||
@ -379,11 +379,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_null_value() {
|
||||
let mut reader = Reader::init("null");
|
||||
let mut reader = Reader::new("null");
|
||||
assert_eq!(null_value(&mut reader).unwrap(), JsonValue::Null {});
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
let error = null_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -397,14 +397,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_boolean_value() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert_eq!(
|
||||
boolean_value(&mut reader).unwrap(),
|
||||
JsonValue::Boolean(true)
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
let error = boolean_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -450,7 +450,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_string_value() {
|
||||
let mut reader = Reader::init("\"\"");
|
||||
let mut reader = Reader::new("\"\"");
|
||||
assert_eq!(
|
||||
string_value(&mut reader).unwrap(),
|
||||
JsonValue::String(Template {
|
||||
@ -461,11 +461,11 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("\"Hello\\u0020{{name}}!\"");
|
||||
let mut reader = Reader::new("\"Hello\\u0020{{name}}!\"");
|
||||
assert_eq!(string_value(&mut reader).unwrap(), json_hello_world_value());
|
||||
assert_eq!(reader.state.cursor, 22);
|
||||
|
||||
let mut reader = Reader::init("\"{}\"");
|
||||
let mut reader = Reader::new("\"{}\"");
|
||||
assert_eq!(
|
||||
string_value(&mut reader).unwrap(),
|
||||
JsonValue::String(Template {
|
||||
@ -482,7 +482,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_string_value_error() {
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
let error = string_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -493,7 +493,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("\"1");
|
||||
let mut reader = Reader::new("\"1");
|
||||
let error = string_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 3 });
|
||||
assert_eq!(
|
||||
@ -504,7 +504,7 @@ mod tests {
|
||||
);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("\"{{x\"");
|
||||
let mut reader = Reader::new("\"{{x\"");
|
||||
let error = string_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 5 });
|
||||
assert_eq!(
|
||||
@ -518,35 +518,35 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_any_char() {
|
||||
let mut reader = Reader::init("a");
|
||||
let mut reader = Reader::new("a");
|
||||
assert_eq!(
|
||||
any_char(&mut reader).unwrap(),
|
||||
('a', "a".to_string(), Pos { line: 1, column: 1 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init(" ");
|
||||
let mut reader = Reader::new(" ");
|
||||
assert_eq!(
|
||||
any_char(&mut reader).unwrap(),
|
||||
(' ', " ".to_string(), Pos { line: 1, column: 1 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("\\u0020 ");
|
||||
let mut reader = Reader::new("\\u0020 ");
|
||||
assert_eq!(
|
||||
any_char(&mut reader).unwrap(),
|
||||
(' ', "\\u0020".to_string(), Pos { line: 1, column: 1 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("\\t");
|
||||
let mut reader = Reader::new("\\t");
|
||||
assert_eq!(
|
||||
any_char(&mut reader).unwrap(),
|
||||
('\t', "\\t".to_string(), Pos { line: 1, column: 1 })
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("#");
|
||||
let mut reader = Reader::new("#");
|
||||
assert_eq!(
|
||||
any_char(&mut reader).unwrap(),
|
||||
('#', "#".to_string(), Pos { line: 1, column: 1 })
|
||||
@ -556,12 +556,12 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_any_char_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = any_char(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("\t");
|
||||
let mut reader = Reader::new("\t");
|
||||
let error = any_char(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
@ -569,15 +569,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_escape_char() {
|
||||
let mut reader = Reader::init("\\n");
|
||||
let mut reader = Reader::new("\\n");
|
||||
assert_eq!(escape_char(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("\\u000a");
|
||||
let mut reader = Reader::new("\\u000a");
|
||||
assert_eq!(escape_char(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = escape_char(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -592,17 +592,17 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unicode() {
|
||||
let mut reader = Reader::init("000a");
|
||||
let mut reader = Reader::new("000a");
|
||||
assert_eq!(unicode(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_hex_value() {
|
||||
let mut reader = Reader::init("0020x");
|
||||
let mut reader = Reader::new("0020x");
|
||||
assert_eq!(hex_value(&mut reader).unwrap(), 32);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = hex_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, error::ParseError::HexDigit);
|
||||
@ -611,49 +611,49 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_number_value() {
|
||||
let mut reader = Reader::init("100");
|
||||
let mut reader = Reader::new("100");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("100".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("1.333");
|
||||
let mut reader = Reader::new("1.333");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("1.333".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("-1");
|
||||
let mut reader = Reader::new("-1");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("-1".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("00");
|
||||
let mut reader = Reader::new("00");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("0".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("1e0");
|
||||
let mut reader = Reader::new("1e0");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("1e0".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("1e005");
|
||||
let mut reader = Reader::new("1e005");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("1e005".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("1e-005");
|
||||
let mut reader = Reader::new("1e-005");
|
||||
assert_eq!(
|
||||
number_value(&mut reader).unwrap(),
|
||||
JsonValue::Number("1e-005".to_string())
|
||||
@ -663,7 +663,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_number_value_error() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
let error = number_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -674,7 +674,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1.x");
|
||||
let mut reader = Reader::new("1.x");
|
||||
let error = number_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 3 });
|
||||
assert_eq!(
|
||||
@ -688,7 +688,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_expression_value() {
|
||||
let mut reader = Reader::init("{{n}}");
|
||||
let mut reader = Reader::new("{{n}}");
|
||||
assert_eq!(
|
||||
expression_value(&mut reader).unwrap(),
|
||||
JsonValue::Expression(Expr {
|
||||
@ -711,7 +711,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_list_value() {
|
||||
let mut reader = Reader::init("[]");
|
||||
let mut reader = Reader::new("[]");
|
||||
assert_eq!(
|
||||
list_value(&mut reader).unwrap(),
|
||||
JsonValue::List {
|
||||
@ -721,7 +721,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("[ ]");
|
||||
let mut reader = Reader::new("[ ]");
|
||||
assert_eq!(
|
||||
list_value(&mut reader).unwrap(),
|
||||
JsonValue::List {
|
||||
@ -731,7 +731,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("[true]");
|
||||
let mut reader = Reader::new("[true]");
|
||||
assert_eq!(
|
||||
list_value(&mut reader).unwrap(),
|
||||
JsonValue::List {
|
||||
@ -748,7 +748,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_list_error() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
let error = list_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -759,7 +759,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("[1, 2,]");
|
||||
let mut reader = Reader::new("[1, 2,]");
|
||||
let error = list_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(error.inner, error::ParseError::Json {});
|
||||
@ -768,7 +768,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_list_element() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert_eq!(
|
||||
list_element(&mut reader).unwrap(),
|
||||
JsonListElement {
|
||||
@ -782,7 +782,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_object_value() {
|
||||
let mut reader = Reader::init("{}");
|
||||
let mut reader = Reader::new("{}");
|
||||
assert_eq!(
|
||||
object_value(&mut reader).unwrap(),
|
||||
JsonValue::Object {
|
||||
@ -792,7 +792,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("{ }");
|
||||
let mut reader = Reader::new("{ }");
|
||||
assert_eq!(
|
||||
object_value(&mut reader).unwrap(),
|
||||
JsonValue::Object {
|
||||
@ -802,7 +802,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("{\n \"a\": true\n}");
|
||||
let mut reader = Reader::new("{\n \"a\": true\n}");
|
||||
assert_eq!(
|
||||
object_value(&mut reader).unwrap(),
|
||||
JsonValue::Object {
|
||||
@ -826,7 +826,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 15);
|
||||
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
let error = object_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -840,7 +840,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_object_error() {
|
||||
let mut reader = Reader::init("{ \"a\":\n}");
|
||||
let mut reader = Reader::new("{ \"a\":\n}");
|
||||
let error = object_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(error.inner, error::ParseError::Json {});
|
||||
@ -849,7 +849,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_object_element() {
|
||||
let mut reader = Reader::init("\"a\": true");
|
||||
let mut reader = Reader::new("\"a\": true");
|
||||
assert_eq!(
|
||||
object_element(&mut reader).unwrap(),
|
||||
JsonObjectElement {
|
||||
@ -873,7 +873,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_object_element_error() {
|
||||
let mut reader = Reader::init(":");
|
||||
let mut reader = Reader::new(":");
|
||||
let error = object_element(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -884,7 +884,7 @@ mod tests {
|
||||
);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("\"name\":\n");
|
||||
let mut reader = Reader::new("\"name\":\n");
|
||||
let error = object_element(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 8 });
|
||||
assert_eq!(error.inner, error::ParseError::Json {});
|
||||
@ -893,15 +893,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_whitespace() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
assert_eq!(whitespace(&mut reader), "".to_string());
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init(" x");
|
||||
let mut reader = Reader::new(" x");
|
||||
assert_eq!(whitespace(&mut reader), " ".to_string());
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("\n x");
|
||||
let mut reader = Reader::new("\n x");
|
||||
assert_eq!(whitespace(&mut reader), "\n ".to_string());
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@ pub type ParseResult<'a, T> = Result<T, Error>;
|
||||
pub type ParseFunc<'a, T> = fn(&mut Reader) -> ParseResult<'a, T>;
|
||||
|
||||
pub fn parse_hurl_file(s: &str) -> ParseResult<'static, HurlFile> {
|
||||
let mut reader = Reader::init(s);
|
||||
let mut reader = Reader::new(s);
|
||||
parsers::hurl_file(&mut reader)
|
||||
}
|
||||
|
||||
|
||||
@ -300,7 +300,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_text() {
|
||||
let mut reader = Reader::init("```\nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("```\nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -323,7 +323,7 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("``` \nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("``` \nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -349,7 +349,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_json() {
|
||||
let mut reader = Reader::init("```json\nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("```json\nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Json(Text {
|
||||
@ -375,7 +375,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_graphql() {
|
||||
let mut reader = Reader::init("```graphql\nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("```graphql\nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::GraphQl(GraphQl {
|
||||
@ -399,7 +399,7 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("```graphql \nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("```graphql \nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::GraphQl(GraphQl {
|
||||
@ -432,14 +432,14 @@ mod tests {
|
||||
];
|
||||
|
||||
for text in datas.iter() {
|
||||
let mut reader = Reader::init(text);
|
||||
let mut reader = Reader::new(text);
|
||||
assert!(multiline_string(&mut reader).is_err())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_empty() {
|
||||
let mut reader = Reader::init("``````");
|
||||
let mut reader = Reader::new("``````");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::OneLineText(Template {
|
||||
@ -449,7 +449,7 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("```\n```");
|
||||
let mut reader = Reader::new("```\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -468,7 +468,7 @@ mod tests {
|
||||
},
|
||||
})
|
||||
);
|
||||
let mut reader = Reader::init("```\r\n```");
|
||||
let mut reader = Reader::new("```\r\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -491,7 +491,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_hello() {
|
||||
let mut reader = Reader::init("```Hello World!```");
|
||||
let mut reader = Reader::new("```Hello World!```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::OneLineText(Template {
|
||||
@ -507,7 +507,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_base64_prefix() {
|
||||
let mut reader = Reader::init("```base64_inline```");
|
||||
let mut reader = Reader::new("```base64_inline```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::OneLineText(Template {
|
||||
@ -523,7 +523,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_csv() {
|
||||
let mut reader = Reader::init("```\nline1\nline2\nline3\n```");
|
||||
let mut reader = Reader::new("```\nline1\nline2\nline3\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -549,7 +549,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_one_empty_line() {
|
||||
let mut reader = Reader::init("```\n\n```");
|
||||
let mut reader = Reader::new("```\n\n```");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -573,7 +573,7 @@ mod tests {
|
||||
);
|
||||
|
||||
// One cr
|
||||
let mut reader = Reader::init("```\n\r\n````");
|
||||
let mut reader = Reader::new("```\n\r\n````");
|
||||
assert_eq!(
|
||||
multiline_string(&mut reader).unwrap(),
|
||||
MultilineString::Text(Text {
|
||||
@ -599,7 +599,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_error() {
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = multiline_string(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -610,13 +610,13 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("```\nxxx");
|
||||
let mut reader = Reader::new("```\nxxx");
|
||||
let error = multiline_string(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 4 });
|
||||
assert_eq!(error.inner, ParseError::Multiline);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("```xxx");
|
||||
let mut reader = Reader::new("```xxx");
|
||||
let error = multiline_string(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 7 });
|
||||
assert_eq!(
|
||||
@ -630,7 +630,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_value() {
|
||||
let mut reader = Reader::init("```");
|
||||
let mut reader = Reader::new("```");
|
||||
assert_eq!(
|
||||
multiline_string_value(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -641,7 +641,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("hello```");
|
||||
let mut reader = Reader::new("hello```");
|
||||
assert_eq!(
|
||||
multiline_string_value(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -658,7 +658,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_graphql_with_variables() {
|
||||
let mut reader = Reader::init(
|
||||
let mut reader = Reader::new(
|
||||
r#"```graphql
|
||||
query Human($name: String!) {
|
||||
human(name: $name) {
|
||||
@ -737,7 +737,7 @@ variables {
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_graphql_with_variables_error() {
|
||||
let mut reader = Reader::init(
|
||||
let mut reader = Reader::new(
|
||||
r#"```graphql
|
||||
query Human($name: String!) {
|
||||
human(name: $name) {
|
||||
@ -765,7 +765,7 @@ variables
|
||||
|
||||
#[test]
|
||||
fn test_multiline_string_graphql_with_variables_not_an_object() {
|
||||
let mut reader = Reader::init(
|
||||
let mut reader = Reader::new(
|
||||
r#"```graphql
|
||||
query Human($name: String!) {
|
||||
human(name: $name) {
|
||||
|
||||
@ -257,14 +257,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_hurl_file() {
|
||||
let mut reader = Reader::init("GET http://google.fr");
|
||||
let mut reader = Reader::new("GET http://google.fr");
|
||||
let hurl_file = hurl_file(&mut reader).unwrap();
|
||||
assert_eq!(hurl_file.entries.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_entry() {
|
||||
let mut reader = Reader::init("GET http://google.fr");
|
||||
let mut reader = Reader::new("GET http://google.fr");
|
||||
let e = entry(&mut reader).unwrap();
|
||||
assert_eq!(e.request.method, Method::Get);
|
||||
assert_eq!(reader.state.cursor, 20);
|
||||
@ -272,7 +272,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_several_entry() {
|
||||
let mut reader = Reader::init("GET http://google.fr\nGET http://google.fr");
|
||||
let mut reader = Reader::new("GET http://google.fr\nGET http://google.fr");
|
||||
|
||||
let e = entry(&mut reader).unwrap();
|
||||
assert_eq!(e.request.method, Method::Get);
|
||||
@ -285,7 +285,7 @@ mod tests {
|
||||
assert_eq!(reader.state.pos.line, 2);
|
||||
|
||||
let mut reader =
|
||||
Reader::init("GET http://google.fr # comment1\nGET http://google.fr # comment2");
|
||||
Reader::new("GET http://google.fr # comment1\nGET http://google.fr # comment2");
|
||||
|
||||
let e = entry(&mut reader).unwrap();
|
||||
assert_eq!(e.request.method, Method::Get);
|
||||
@ -300,7 +300,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_entry_with_response() {
|
||||
let mut reader = Reader::init("GET http://google.fr\nHTTP/1.1 200");
|
||||
let mut reader = Reader::new("GET http://google.fr\nHTTP/1.1 200");
|
||||
let e = entry(&mut reader).unwrap();
|
||||
assert_eq!(e.request.method, Method::Get);
|
||||
assert_eq!(e.response.unwrap().status.value, StatusValue::Specific(200));
|
||||
@ -308,7 +308,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_request() {
|
||||
let mut reader = Reader::init("GET http://google.fr");
|
||||
let mut reader = Reader::new("GET http://google.fr");
|
||||
let default_request = Request {
|
||||
line_terminators: vec![],
|
||||
space0: Whitespace {
|
||||
@ -346,7 +346,7 @@ mod tests {
|
||||
};
|
||||
assert_eq!(request(&mut reader), Ok(default_request));
|
||||
|
||||
let mut reader = Reader::init("GET http://google.fr # comment");
|
||||
let mut reader = Reader::new("GET http://google.fr # comment");
|
||||
let default_request = Request {
|
||||
line_terminators: vec![],
|
||||
space0: Whitespace {
|
||||
@ -386,7 +386,7 @@ mod tests {
|
||||
};
|
||||
assert_eq!(request(&mut reader), Ok(default_request));
|
||||
|
||||
let mut reader = Reader::init("GET http://google.fr\nGET http://google.fr");
|
||||
let mut reader = Reader::new("GET http://google.fr\nGET http://google.fr");
|
||||
let r = request(&mut reader);
|
||||
assert_eq!(r.unwrap().method, Method::Get);
|
||||
assert_eq!(reader.state.cursor, 21);
|
||||
@ -400,7 +400,7 @@ mod tests {
|
||||
// ```
|
||||
// Hello World!
|
||||
// ```
|
||||
let mut reader = Reader::init("GET http://google.fr\n```\nHello World!\n```");
|
||||
let mut reader = Reader::new("GET http://google.fr\n```\nHello World!\n```");
|
||||
let req = request(&mut reader).unwrap();
|
||||
assert_eq!(
|
||||
req.body.unwrap(),
|
||||
@ -445,7 +445,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_request_post_json() {
|
||||
let mut reader = Reader::init("POST http://localhost:8000/post-json-array\n[1,2,3]");
|
||||
let mut reader = Reader::new("POST http://localhost:8000/post-json-array\n[1,2,3]");
|
||||
let r = request(&mut reader).unwrap();
|
||||
assert_eq!(r.method, Method::Post);
|
||||
assert_eq!(
|
||||
@ -472,7 +472,7 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("POST http://localhost:8000/post-json-string\n\"Hello\"");
|
||||
let mut reader = Reader::new("POST http://localhost:8000/post-json-string\n\"Hello\"");
|
||||
let r = request(&mut reader).unwrap();
|
||||
assert_eq!(r.method, Method::Post);
|
||||
assert_eq!(
|
||||
@ -487,7 +487,7 @@ mod tests {
|
||||
}))
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("POST http://localhost:8000/post-json-number\n100");
|
||||
let mut reader = Reader::new("POST http://localhost:8000/post-json-number\n100");
|
||||
let r = request(&mut reader).unwrap();
|
||||
assert_eq!(r.method, Method::Post);
|
||||
assert_eq!(
|
||||
@ -498,14 +498,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_request_error() {
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = request(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_response() {
|
||||
let mut reader = Reader::init("HTTP/1.1 200");
|
||||
let mut reader = Reader::new("HTTP/1.1 200");
|
||||
//println!("{:?}", response(&mut reader));
|
||||
let r = response(&mut reader).unwrap();
|
||||
|
||||
@ -515,49 +515,49 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_method() {
|
||||
let mut reader = Reader::init("xxx ");
|
||||
let mut reader = Reader::new("xxx ");
|
||||
let error = method(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = method(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init("GET ");
|
||||
let mut reader = Reader::new("GET ");
|
||||
assert_eq!(Ok(Method::Get), method(&mut reader));
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version() {
|
||||
let mut reader = Reader::init("HTTP/1.1 200");
|
||||
let mut reader = Reader::new("HTTP/1.1 200");
|
||||
assert_eq!(version(&mut reader).unwrap().value, VersionValue::Version11);
|
||||
|
||||
let mut reader = Reader::init("HTTP/1. 200");
|
||||
let mut reader = Reader::new("HTTP/1. 200");
|
||||
let error = version(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_status() {
|
||||
let mut reader = Reader::init("*");
|
||||
let mut reader = Reader::new("*");
|
||||
let s = status(&mut reader).unwrap();
|
||||
assert_eq!(s.value, StatusValue::Any);
|
||||
|
||||
let mut reader = Reader::init("200");
|
||||
let mut reader = Reader::new("200");
|
||||
let s = status(&mut reader).unwrap();
|
||||
assert_eq!(s.value, StatusValue::Specific(200));
|
||||
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let result = status(&mut reader);
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_body_json() {
|
||||
let mut reader = Reader::init("[1,2,3] ");
|
||||
let mut reader = Reader::new("[1,2,3] ");
|
||||
let b = body(&mut reader).unwrap();
|
||||
assert_eq!(b.line_terminators.len(), 0);
|
||||
assert_eq!(
|
||||
@ -585,7 +585,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 8);
|
||||
|
||||
let mut reader = Reader::init("{}");
|
||||
let mut reader = Reader::new("{}");
|
||||
let b = body(&mut reader).unwrap();
|
||||
assert_eq!(b.line_terminators.len(), 0);
|
||||
assert_eq!(
|
||||
@ -597,7 +597,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("# comment\n {} # comment\nxxx");
|
||||
let mut reader = Reader::new("# comment\n {} # comment\nxxx");
|
||||
let b = body(&mut reader).unwrap();
|
||||
assert_eq!(b.line_terminators.len(), 1);
|
||||
assert_eq!(
|
||||
@ -609,7 +609,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 24);
|
||||
|
||||
let mut reader = Reader::init("{x");
|
||||
let mut reader = Reader::new("{x");
|
||||
let error = body(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(!error.recoverable);
|
||||
|
||||
@ -370,7 +370,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_not() {
|
||||
let mut reader = Reader::init("notXX");
|
||||
let mut reader = Reader::new("notXX");
|
||||
assert_eq!(
|
||||
predicate_not(&mut reader),
|
||||
(
|
||||
@ -383,7 +383,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.pos, Pos { line: 1, column: 1 });
|
||||
|
||||
let mut reader = Reader::init("not XX");
|
||||
let mut reader = Reader::new("not XX");
|
||||
assert_eq!(
|
||||
predicate_not(&mut reader),
|
||||
(
|
||||
@ -399,7 +399,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate() {
|
||||
let mut reader = Reader::init("not equals true");
|
||||
let mut reader = Reader::new("not equals true");
|
||||
assert_eq!(
|
||||
predicate(&mut reader).unwrap(),
|
||||
Predicate {
|
||||
@ -425,7 +425,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_error() {
|
||||
let mut reader = Reader::init("countEquals true");
|
||||
let mut reader = Reader::new("countEquals true");
|
||||
let error = predicate(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -440,7 +440,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_func() {
|
||||
let mut reader = Reader::init("tata equals 1");
|
||||
let mut reader = Reader::new("tata equals 1");
|
||||
let error = predicate_func(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(!error.recoverable);
|
||||
@ -449,7 +449,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_equal_predicate() {
|
||||
let mut reader = Reader::init("equals true");
|
||||
let mut reader = Reader::new("equals true");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -463,7 +463,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("equals 1.1");
|
||||
let mut reader = Reader::new("equals 1.1");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -479,7 +479,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("equals 2");
|
||||
let mut reader = Reader::new("equals 2");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -492,7 +492,7 @@ mod tests {
|
||||
},
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("== 2");
|
||||
let mut reader = Reader::new("== 2");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -505,7 +505,7 @@ mod tests {
|
||||
},
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("equals \"Bob\"");
|
||||
let mut reader = Reader::new("equals \"Bob\"");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -528,7 +528,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_equal_expression_predicate() {
|
||||
let mut reader = Reader::init("equals {{count}}");
|
||||
let mut reader = Reader::new("equals {{count}}");
|
||||
assert_eq!(
|
||||
equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::Equal {
|
||||
@ -557,7 +557,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_count_equal_predicate() {
|
||||
let mut reader = Reader::init("countEquals 2");
|
||||
let mut reader = Reader::new("countEquals 2");
|
||||
assert_eq!(
|
||||
count_equal_predicate(&mut reader).unwrap(),
|
||||
PredicateFuncValue::CountEqual {
|
||||
@ -569,7 +569,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("countEquals true");
|
||||
let mut reader = Reader::new("countEquals true");
|
||||
let error = count_equal_predicate(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -584,7 +584,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_start_with_predicate() {
|
||||
let mut reader = Reader::init("startsWith 2");
|
||||
let mut reader = Reader::new("startsWith 2");
|
||||
let error = start_with_predicate(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
|
||||
@ -88,19 +88,19 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_value() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert_eq!(
|
||||
predicate_value(&mut reader).unwrap(),
|
||||
PredicateValue::Bool(true)
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
assert_eq!(
|
||||
predicate_value(&mut reader).unwrap(),
|
||||
PredicateValue::Integer(1)
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("1.1");
|
||||
let mut reader = Reader::new("1.1");
|
||||
assert_eq!(
|
||||
predicate_value(&mut reader).unwrap(),
|
||||
PredicateValue::Float(Float {
|
||||
@ -112,7 +112,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_value_error() {
|
||||
let mut reader = Reader::init("xx");
|
||||
let mut reader = Reader::new("xx");
|
||||
let error = predicate_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::PredicateValue {});
|
||||
@ -121,7 +121,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_predicate_value_error_missing_quote() {
|
||||
let mut reader = Reader::init("\"not_found");
|
||||
let mut reader = Reader::new("\"not_found");
|
||||
let error = predicate_value(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
|
||||
@ -316,7 +316,7 @@ pub fn hex(reader: &mut Reader) -> ParseResult<'static, Hex> {
|
||||
inner: ParseError::OddNumberOfHexDigits {},
|
||||
});
|
||||
}
|
||||
let encoded = reader.from(start);
|
||||
let encoded = reader.peek_back(start);
|
||||
let space1 = zero_or_more_spaces(reader)?;
|
||||
literal(";", reader)?;
|
||||
|
||||
@ -494,7 +494,7 @@ pub fn float(reader: &mut Reader) -> ParseResult<'static, Float> {
|
||||
});
|
||||
}
|
||||
let value = format!("{sign}{nat}.{s}").parse().unwrap();
|
||||
let encoded = reader.from(start);
|
||||
let encoded = reader.peek_back(start);
|
||||
Ok(Float { value, encoded })
|
||||
}
|
||||
|
||||
@ -597,12 +597,12 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_space() {
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = space(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init(" ");
|
||||
let mut reader = Reader::new(" ");
|
||||
assert_eq!(
|
||||
space(&mut reader),
|
||||
Ok(Whitespace {
|
||||
@ -615,7 +615,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_one_or_more_spaces() {
|
||||
let mut reader = Reader::init(" ");
|
||||
let mut reader = Reader::new(" ");
|
||||
assert_eq!(
|
||||
one_or_more_spaces(&mut reader),
|
||||
Ok(Whitespace {
|
||||
@ -624,14 +624,14 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("abc");
|
||||
let mut reader = Reader::new("abc");
|
||||
let error = one_or_more_spaces(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zero_or_more_spaces() {
|
||||
let mut reader = Reader::init(" ");
|
||||
let mut reader = Reader::new(" ");
|
||||
assert_eq!(
|
||||
zero_or_more_spaces(&mut reader),
|
||||
Ok(Whitespace {
|
||||
@ -641,7 +641,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
assert_eq!(
|
||||
zero_or_more_spaces(&mut reader),
|
||||
Ok(Whitespace {
|
||||
@ -651,7 +651,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init(" xxx");
|
||||
let mut reader = Reader::new(" xxx");
|
||||
assert_eq!(
|
||||
zero_or_more_spaces(&mut reader),
|
||||
Ok(Whitespace {
|
||||
@ -673,7 +673,7 @@ mod tests {
|
||||
// );
|
||||
// assert_eq!(reader.state.cursor, 9);
|
||||
|
||||
let mut reader = Reader::init("#\n");
|
||||
let mut reader = Reader::new("#\n");
|
||||
assert_eq!(
|
||||
comment(&mut reader),
|
||||
Ok(Comment {
|
||||
@ -681,7 +681,7 @@ mod tests {
|
||||
})
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("# comment\n");
|
||||
let mut reader = Reader::new("# comment\n");
|
||||
assert_eq!(
|
||||
comment(&mut reader),
|
||||
Ok(Comment {
|
||||
@ -690,7 +690,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 9);
|
||||
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = comment(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
@ -698,11 +698,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_literal() {
|
||||
let mut reader = Reader::init("hello");
|
||||
let mut reader = Reader::new("hello");
|
||||
assert_eq!(literal("hello", &mut reader), Ok(()));
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -713,7 +713,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -724,7 +724,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("he");
|
||||
let mut reader = Reader::new("he");
|
||||
let error = literal("hello", &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -738,7 +738,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_new_line() {
|
||||
let mut reader = Reader::init("\n");
|
||||
let mut reader = Reader::new("\n");
|
||||
assert_eq!(
|
||||
newline(&mut reader).unwrap(),
|
||||
Whitespace {
|
||||
@ -750,7 +750,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_key_value() {
|
||||
let mut reader = Reader::init("message: hello {{name}}! # comment");
|
||||
let mut reader = Reader::new("message: hello {{name}}! # comment");
|
||||
assert_eq!(
|
||||
key_value(&mut reader).unwrap(),
|
||||
KeyValue {
|
||||
@ -820,10 +820,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_boolean() {
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert!(boolean(&mut reader).unwrap());
|
||||
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = boolean(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -833,7 +833,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("trux");
|
||||
let mut reader = Reader::new("trux");
|
||||
let error = boolean(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -846,22 +846,22 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_natural() {
|
||||
let mut reader = Reader::init("0");
|
||||
let mut reader = Reader::new("0");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 0);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("0.");
|
||||
let mut reader = Reader::new("0.");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 0);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("10x");
|
||||
let mut reader = Reader::new("10x");
|
||||
assert_eq!(natural(&mut reader).unwrap(), 10);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_natural_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -872,7 +872,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("01");
|
||||
let mut reader = Reader::new("01");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert_eq!(
|
||||
@ -883,7 +883,7 @@ mod tests {
|
||||
);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = natural(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -897,16 +897,16 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_integer() {
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), 1);
|
||||
|
||||
let mut reader = Reader::init("1.1");
|
||||
let mut reader = Reader::new("1.1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), 1);
|
||||
|
||||
let mut reader = Reader::init("-1.1");
|
||||
let mut reader = Reader::new("-1.1");
|
||||
assert_eq!(integer(&mut reader).unwrap(), -1);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = integer(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -920,7 +920,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_float() {
|
||||
let mut reader = Reader::init("1.0");
|
||||
let mut reader = Reader::new("1.0");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -930,7 +930,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("-1.0");
|
||||
let mut reader = Reader::new("-1.0");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -940,7 +940,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("1.1");
|
||||
let mut reader = Reader::new("1.1");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -950,7 +950,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("1.100");
|
||||
let mut reader = Reader::new("1.100");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -960,7 +960,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
let mut reader = Reader::init("1.01");
|
||||
let mut reader = Reader::new("1.01");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -970,7 +970,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("1.010");
|
||||
let mut reader = Reader::new("1.010");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -981,7 +981,7 @@ mod tests {
|
||||
assert_eq!(reader.state.cursor, 5);
|
||||
|
||||
// provide more digits than necessary
|
||||
let mut reader = Reader::init("-0.3333333333333333333");
|
||||
let mut reader = Reader::new("-0.3333333333333333333");
|
||||
assert_eq!(
|
||||
float(&mut reader).unwrap(),
|
||||
Float {
|
||||
@ -994,7 +994,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_float_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1005,7 +1005,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("-");
|
||||
let mut reader = Reader::new("-");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1016,7 +1016,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1027,7 +1027,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1x");
|
||||
let mut reader = Reader::new("1x");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1038,7 +1038,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1.");
|
||||
let mut reader = Reader::new("1.");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1049,7 +1049,7 @@ mod tests {
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 3 });
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("1.x");
|
||||
let mut reader = Reader::new("1.x");
|
||||
let error = float(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.inner,
|
||||
@ -1063,10 +1063,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_hex_digit() {
|
||||
let mut reader = Reader::init("0");
|
||||
let mut reader = Reader::new("0");
|
||||
assert_eq!(hex_digit(&mut reader).unwrap(), 0);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = hex_digit(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::HexDigit {});
|
||||
@ -1075,7 +1075,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_hex() {
|
||||
let mut reader = Reader::init("hex, ff;");
|
||||
let mut reader = Reader::new("hex, ff;");
|
||||
assert_eq!(
|
||||
hex(&mut reader).unwrap(),
|
||||
Hex {
|
||||
@ -1092,7 +1092,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("hex,010203 ;");
|
||||
let mut reader = Reader::new("hex,010203 ;");
|
||||
assert_eq!(
|
||||
hex(&mut reader).unwrap(),
|
||||
Hex {
|
||||
@ -1112,7 +1112,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_hex_error() {
|
||||
let mut reader = Reader::init("hex,012;");
|
||||
let mut reader = Reader::new("hex,012;");
|
||||
let error = hex(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 8 });
|
||||
assert_eq!(error.inner, ParseError::OddNumberOfHexDigits {});
|
||||
@ -1120,7 +1120,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_regex() {
|
||||
let mut reader = Reader::init(r#"/a{3}/"#);
|
||||
let mut reader = Reader::new(r#"/a{3}/"#);
|
||||
assert_eq!(
|
||||
regex(&mut reader).unwrap(),
|
||||
Regex {
|
||||
@ -1128,7 +1128,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init(r#"/a\/b/"#);
|
||||
let mut reader = Reader::new(r#"/a\/b/"#);
|
||||
assert_eq!(
|
||||
regex(&mut reader).unwrap(),
|
||||
Regex {
|
||||
@ -1136,7 +1136,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init(r#"/a\.b/"#);
|
||||
let mut reader = Reader::new(r#"/a\.b/"#);
|
||||
assert_eq!(
|
||||
regex(&mut reader).unwrap(),
|
||||
Regex {
|
||||
@ -1144,7 +1144,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init(r#"/\d{4}-\d{2}-\d{2}/"#);
|
||||
let mut reader = Reader::new(r#"/\d{4}-\d{2}-\d{2}/"#);
|
||||
assert_eq!(
|
||||
regex(&mut reader).unwrap(),
|
||||
Regex {
|
||||
@ -1155,18 +1155,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_regex_error() {
|
||||
let mut reader = Reader::init("xxx");
|
||||
let mut reader = Reader::new("xxx");
|
||||
let error = regex(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("/xxx");
|
||||
let mut reader = Reader::new("/xxx");
|
||||
let error = regex(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 5 });
|
||||
assert!(!error.recoverable);
|
||||
assert_eq!(error.inner, ParseError::Eof {});
|
||||
|
||||
let mut reader = Reader::init("/x{a}/");
|
||||
let mut reader = Reader::new("/x{a}/");
|
||||
let error = regex(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert!(!error.recoverable);
|
||||
@ -1180,7 +1180,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_file() {
|
||||
let mut reader = Reader::init("file,data.xml;");
|
||||
let mut reader = Reader::new("file,data.xml;");
|
||||
assert_eq!(
|
||||
file(&mut reader).unwrap(),
|
||||
File {
|
||||
@ -1199,7 +1199,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("file, filename1;");
|
||||
let mut reader = Reader::new("file, filename1;");
|
||||
assert_eq!(
|
||||
file(&mut reader).unwrap(),
|
||||
File {
|
||||
@ -1218,7 +1218,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("file, tmp/filename1;");
|
||||
let mut reader = Reader::new("file, tmp/filename1;");
|
||||
assert_eq!(
|
||||
file(&mut reader).unwrap(),
|
||||
File {
|
||||
@ -1237,7 +1237,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init(r#"file, tmp/filename\ with\ spaces.txt;"#);
|
||||
let mut reader = Reader::new(r#"file, tmp/filename\ with\ spaces.txt;"#);
|
||||
assert_eq!(
|
||||
file(&mut reader).unwrap(),
|
||||
File {
|
||||
@ -1259,12 +1259,12 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_file_error() {
|
||||
let mut reader = Reader::init("fil; filename1;");
|
||||
let mut reader = Reader::new("fil; filename1;");
|
||||
let error = file(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("file, filename1");
|
||||
let mut reader = Reader::new("file, filename1");
|
||||
let error = file(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -1281,7 +1281,7 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init(r#"file, tmp/filename\ with\ unescaped .txt;"#);
|
||||
let mut reader = Reader::new(r#"file, tmp/filename\ with\ unescaped .txt;"#);
|
||||
let error = file(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -1301,7 +1301,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_base64() {
|
||||
let mut reader = Reader::init("base64, T WE=;xxx");
|
||||
let mut reader = Reader::new("base64, T WE=;xxx");
|
||||
assert_eq!(
|
||||
base64(&mut reader).unwrap(),
|
||||
Base64 {
|
||||
|
||||
@ -80,7 +80,7 @@ fn cookie_query(reader: &mut Reader) -> ParseResult<'static, QueryValue> {
|
||||
// todo should work with an encodedString in order to support escape sequence
|
||||
// or decode escape sequence with the cookiepath parser
|
||||
|
||||
let mut cookiepath_reader = Reader::init(s.as_str());
|
||||
let mut cookiepath_reader = Reader::new(s.as_str());
|
||||
cookiepath_reader.state.pos = Pos {
|
||||
line: start.line,
|
||||
column: start.column + 1,
|
||||
@ -222,7 +222,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_query() {
|
||||
let mut reader = Reader::init("status");
|
||||
let mut reader = Reader::new("status");
|
||||
assert_eq!(
|
||||
query(&mut reader).unwrap(),
|
||||
Query {
|
||||
@ -234,7 +234,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_status_query() {
|
||||
let mut reader = Reader::init("status");
|
||||
let mut reader = Reader::new("status");
|
||||
assert_eq!(
|
||||
query(&mut reader).unwrap(),
|
||||
Query {
|
||||
@ -246,7 +246,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_header_query() {
|
||||
let mut reader = Reader::init("header \"Foo\"");
|
||||
let mut reader = Reader::new("header \"Foo\"");
|
||||
assert_eq!(
|
||||
header_query(&mut reader).unwrap(),
|
||||
QueryValue::Header {
|
||||
@ -268,7 +268,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookie_query() {
|
||||
let mut reader = Reader::init("cookie \"Foo[Domain]\"");
|
||||
let mut reader = Reader::new("cookie \"Foo[Domain]\"");
|
||||
assert_eq!(
|
||||
cookie_query(&mut reader).unwrap(),
|
||||
QueryValue::Cookie {
|
||||
@ -307,7 +307,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_xpath_query() {
|
||||
let mut reader = Reader::init("xpath \"normalize-space(//head/title)\"");
|
||||
let mut reader = Reader::new("xpath \"normalize-space(//head/title)\"");
|
||||
assert_eq!(
|
||||
xpath_query(&mut reader).unwrap(),
|
||||
QueryValue::Xpath {
|
||||
@ -326,7 +326,7 @@ mod tests {
|
||||
},
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("xpath \"normalize-space(//div[contains(concat(' ',normalize-space(@class),' '),' monthly-price ')])\"");
|
||||
let mut reader = Reader::new("xpath \"normalize-space(//div[contains(concat(' ',normalize-space(@class),' '),' monthly-price ')])\"");
|
||||
assert_eq!(xpath_query(&mut reader).unwrap(), QueryValue::Xpath {
|
||||
space0: Whitespace { value: String::from(" "), source_info: SourceInfo::new(1, 6, 1, 7) },
|
||||
expr: Template {
|
||||
@ -345,7 +345,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_jsonpath_query() {
|
||||
let mut reader = Reader::init("jsonpath \"$['statusCode']\"");
|
||||
let mut reader = Reader::new("jsonpath \"$['statusCode']\"");
|
||||
assert_eq!(
|
||||
jsonpath_query(&mut reader).unwrap(),
|
||||
QueryValue::Jsonpath {
|
||||
@ -363,7 +363,7 @@ mod tests {
|
||||
},
|
||||
},
|
||||
);
|
||||
let mut reader = Reader::init("jsonpath \"$.success\"");
|
||||
let mut reader = Reader::new("jsonpath \"$.success\"");
|
||||
assert_eq!(
|
||||
jsonpath_query(&mut reader).unwrap(),
|
||||
QueryValue::Jsonpath {
|
||||
@ -385,7 +385,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_query_with_filters() {
|
||||
let mut reader = Reader::init("body urlDecode ");
|
||||
let mut reader = Reader::new("body urlDecode ");
|
||||
assert_eq!(
|
||||
query(&mut reader).unwrap(),
|
||||
Query {
|
||||
|
||||
@ -19,6 +19,24 @@ use std::cmp::min;
|
||||
|
||||
use crate::ast::Pos;
|
||||
|
||||
/// Represents a text reader.
|
||||
///
|
||||
/// The `Reader` implements methods to read a stream of text. A reader manages
|
||||
/// an internal `state` which is the position of the current cursor within the reader's buffer.
|
||||
/// Methods like [`Reader::read`], [`Reader::read_while`], [`Reader::read_while_escaping`]
|
||||
/// do advance the internal reader's`state`. Other methods, like [`Reader::peek`], [`Reader::peek_k`]
|
||||
/// allows to get the next chars in the buffer without modifying the current reader state.
|
||||
///
|
||||
/// # Example
|
||||
/// ```
|
||||
/// use hurl_core::parser::Reader;
|
||||
///
|
||||
/// let mut reader = Reader::new("hi");
|
||||
/// let state = reader.state.cursor; // cursor is 0
|
||||
/// let eof = reader.is_eof();
|
||||
/// let val = reader.peek_n(2); // val = "hi"
|
||||
/// let val = reader.read().unwrap(); // val = 'h'
|
||||
/// ```
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Reader {
|
||||
pub buffer: Vec<char>,
|
||||
@ -32,8 +50,8 @@ pub struct ReaderState {
|
||||
}
|
||||
|
||||
impl Reader {
|
||||
// FIXME: change name to the more idiomatic new
|
||||
pub fn init(s: &str) -> Reader {
|
||||
/// Creates a new reader.
|
||||
pub fn new(s: &str) -> Reader {
|
||||
Reader {
|
||||
buffer: s.chars().collect(),
|
||||
state: ReaderState {
|
||||
@ -43,10 +61,12 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the reader has read all the buffer, false otherwise.
|
||||
pub fn is_eof(&self) -> bool {
|
||||
self.state.cursor == self.buffer.len()
|
||||
}
|
||||
|
||||
/// Returns the next char from the buffer advancing the internal state.
|
||||
pub fn read(&mut self) -> Option<char> {
|
||||
match self.buffer.get(self.state.cursor) {
|
||||
None => None,
|
||||
@ -64,16 +84,20 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn peek(&mut self) -> Option<char> {
|
||||
self.buffer.get(self.state.cursor).copied()
|
||||
}
|
||||
|
||||
pub fn peek_n(&self, n: usize) -> String {
|
||||
let start = self.state.cursor;
|
||||
let end = min(start + n, self.buffer.len());
|
||||
self.buffer[start..end].iter().collect()
|
||||
/// Returns `count` chars from the buffer advancing the internal state.
|
||||
/// This methods can returns less than `count` chars if there is not enough chars in the buffer.
|
||||
pub fn read_n(&mut self, count: usize) -> String {
|
||||
let mut s = String::from("");
|
||||
for _ in 0..count {
|
||||
match self.read() {
|
||||
None => {}
|
||||
Some(c) => s.push(c),
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Returns chars from the buffer while `predicate` is true, advancing the internal state.
|
||||
pub fn read_while(&mut self, predicate: fn(&char) -> bool) -> String {
|
||||
let mut s = String::from("");
|
||||
loop {
|
||||
@ -114,16 +138,17 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
// assume that you still have count characters to read in your buffer
|
||||
pub fn read_n(&mut self, count: usize) -> String {
|
||||
let mut s = String::from("");
|
||||
for _ in 0..count {
|
||||
match self.read() {
|
||||
None => {}
|
||||
Some(c) => s.push(c),
|
||||
}
|
||||
}
|
||||
s
|
||||
/// Returns the next char from the buffer without advancing the internal state.
|
||||
pub fn peek(&mut self) -> Option<char> {
|
||||
self.buffer.get(self.state.cursor).copied()
|
||||
}
|
||||
|
||||
/// Returns the `count` char from the buffer without advancing the internal state.
|
||||
/// This methods can returns less than `count` chars if there is not enough chars in the buffer.
|
||||
pub fn peek_n(&self, count: usize) -> String {
|
||||
let start = self.state.cursor;
|
||||
let end = min(start + count, self.buffer.len());
|
||||
self.buffer[start..end].iter().collect()
|
||||
}
|
||||
|
||||
pub fn try_literal(&mut self, value: &str) -> bool {
|
||||
@ -135,10 +160,9 @@ impl Reader {
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: explain this method, find a better name mayebe?
|
||||
pub fn from(&self, start: usize) -> String {
|
||||
pub fn peek_back(&self, start: usize) -> String {
|
||||
let end = self.state.cursor;
|
||||
self.buffer.as_slice()[start..end].iter().collect()
|
||||
self.buffer[start..end].iter().collect()
|
||||
}
|
||||
}
|
||||
|
||||
@ -152,7 +176,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_reader() {
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
assert!(!reader.is_eof());
|
||||
assert_eq!(reader.peek_n(2), "hi".to_string());
|
||||
@ -168,11 +192,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_try_predicate() {
|
||||
let mut reader = Reader::init("hi");
|
||||
let mut reader = Reader::new("hi");
|
||||
assert!(reader.try_literal("hi"));
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("hello");
|
||||
let mut reader = Reader::new("hello");
|
||||
assert!(!reader.try_literal("hi"));
|
||||
assert_eq!(reader.state.cursor, 0);
|
||||
}
|
||||
|
||||
@ -738,17 +738,17 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_section_name() {
|
||||
let mut reader = Reader::init("[SectionA]");
|
||||
let mut reader = Reader::new("[SectionA]");
|
||||
assert_eq!(section_name(&mut reader).unwrap(), String::from("SectionA"));
|
||||
|
||||
let mut reader = Reader::init("[]");
|
||||
let mut reader = Reader::new("[]");
|
||||
assert!(section_name(&mut reader).err().unwrap().recoverable);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_asserts_section() {
|
||||
let mut reader =
|
||||
Reader::init("[Asserts]\nheader \"Location\" equals \"https://google.fr\"\n");
|
||||
Reader::new("[Asserts]\nheader \"Location\" equals \"https://google.fr\"\n");
|
||||
|
||||
assert_eq!(
|
||||
response_section(&mut reader).unwrap(),
|
||||
@ -841,8 +841,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_asserts_section_error() {
|
||||
let mut reader =
|
||||
Reader::init("x[Assertsx]\nheader Location equals \"https://google.fr\"\n");
|
||||
let mut reader = Reader::new("x[Assertsx]\nheader Location equals \"https://google.fr\"\n");
|
||||
let error = response_section(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -853,7 +852,7 @@ mod tests {
|
||||
);
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("[Assertsx]\nheader Location equals \"https://google.fr\"\n");
|
||||
let mut reader = Reader::new("[Assertsx]\nheader Location equals \"https://google.fr\"\n");
|
||||
let error = response_section(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert_eq!(
|
||||
@ -867,7 +866,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookie() {
|
||||
let mut reader = Reader::init("Foo: Bar");
|
||||
let mut reader = Reader::new("Foo: Bar");
|
||||
let c = cookie(&mut reader).unwrap();
|
||||
assert_eq!(c.name.value, String::from("Foo"));
|
||||
assert_eq!(
|
||||
@ -885,7 +884,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_option_insecure() {
|
||||
let mut reader = Reader::init("insecure: true");
|
||||
let mut reader = Reader::new("insecure: true");
|
||||
let option = option_insecure(&mut reader).unwrap();
|
||||
assert_eq!(
|
||||
option,
|
||||
@ -954,14 +953,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_option_insecure_error() {
|
||||
let mut reader = Reader::init("insecure: error");
|
||||
let mut reader = Reader::new("insecure: error");
|
||||
let error = option_insecure(&mut reader).err().unwrap();
|
||||
assert!(!error.recoverable)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_option_cacert() {
|
||||
let mut reader = Reader::init("cacert: /home/foo/cert.pem");
|
||||
let mut reader = Reader::new("cacert: /home/foo/cert.pem");
|
||||
let option = option_cacert(&mut reader).unwrap();
|
||||
assert_eq!(
|
||||
option,
|
||||
@ -1033,14 +1032,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_option_cacert_error() {
|
||||
let mut reader = Reader::init("cacert: ###");
|
||||
let mut reader = Reader::new("cacert: ###");
|
||||
let error = option_cacert(&mut reader).err().unwrap();
|
||||
assert!(!error.recoverable)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_variable_definition() {
|
||||
let mut reader = Reader::init("a=1");
|
||||
let mut reader = Reader::new("a=1");
|
||||
assert_eq!(
|
||||
variable_definition(&mut reader).unwrap(),
|
||||
VariableDefinition {
|
||||
@ -1066,22 +1065,22 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_variable_value() {
|
||||
let mut reader = Reader::init("null");
|
||||
let mut reader = Reader::new("null");
|
||||
assert_eq!(variable_value(&mut reader).unwrap(), VariableValue::Null {});
|
||||
|
||||
let mut reader = Reader::init("true");
|
||||
let mut reader = Reader::new("true");
|
||||
assert_eq!(
|
||||
variable_value(&mut reader).unwrap(),
|
||||
VariableValue::Bool(true)
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("1");
|
||||
let mut reader = Reader::new("1");
|
||||
assert_eq!(
|
||||
variable_value(&mut reader).unwrap(),
|
||||
VariableValue::Integer(1)
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("toto");
|
||||
let mut reader = Reader::new("toto");
|
||||
assert_eq!(
|
||||
variable_value(&mut reader).unwrap(),
|
||||
VariableValue::String(Template {
|
||||
@ -1096,7 +1095,7 @@ mod tests {
|
||||
},
|
||||
})
|
||||
);
|
||||
let mut reader = Reader::init("\"123\"");
|
||||
let mut reader = Reader::new("\"123\"");
|
||||
assert_eq!(
|
||||
variable_value(&mut reader).unwrap(),
|
||||
VariableValue::String(Template {
|
||||
@ -1115,7 +1114,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_cookie_error() {
|
||||
let mut reader = Reader::init("Foo: {{Bar");
|
||||
let mut reader = Reader::new("Foo: {{Bar");
|
||||
let error = cookie(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -1135,7 +1134,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_file_value() {
|
||||
let mut reader = Reader::init("file,hello.txt;");
|
||||
let mut reader = Reader::new("file,hello.txt;");
|
||||
assert_eq!(
|
||||
file_value(&mut reader).unwrap(),
|
||||
FileValue {
|
||||
@ -1158,7 +1157,7 @@ mod tests {
|
||||
content_type: None,
|
||||
}
|
||||
);
|
||||
let mut reader = Reader::init("file,hello.txt; text/html");
|
||||
let mut reader = Reader::new("file,hello.txt; text/html");
|
||||
assert_eq!(
|
||||
file_value(&mut reader).unwrap(),
|
||||
FileValue {
|
||||
@ -1185,21 +1184,21 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_file_content_type() {
|
||||
let mut reader = Reader::init("text/html");
|
||||
let mut reader = Reader::new("text/html");
|
||||
assert_eq!(
|
||||
file_content_type(&mut reader).unwrap(),
|
||||
"text/html".to_string()
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 9);
|
||||
|
||||
let mut reader = Reader::init("text/plain; charset=us-ascii");
|
||||
let mut reader = Reader::new("text/plain; charset=us-ascii");
|
||||
assert_eq!(
|
||||
file_content_type(&mut reader).unwrap(),
|
||||
"text/plain; charset=us-ascii".to_string()
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 28);
|
||||
|
||||
let mut reader = Reader::init("text/html # comment");
|
||||
let mut reader = Reader::new("text/html # comment");
|
||||
assert_eq!(
|
||||
file_content_type(&mut reader).unwrap(),
|
||||
"text/html".to_string()
|
||||
@ -1209,7 +1208,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_capture() {
|
||||
let mut reader = Reader::init("url: header \"Location\"");
|
||||
let mut reader = Reader::new("url: header \"Location\"");
|
||||
let capture0 = capture(&mut reader).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
@ -1245,7 +1244,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_capture_with_filter() {
|
||||
let mut reader = Reader::init("token: header \"Location\" regex \"token=(.*)\"");
|
||||
let mut reader = Reader::new("token: header \"Location\" regex \"token=(.*)\"");
|
||||
let capture0 = capture(&mut reader).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
@ -1273,7 +1272,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_capture_with_filter_error() {
|
||||
let mut reader = Reader::init("token: header \"Location\" regex ");
|
||||
let mut reader = Reader::new("token: header \"Location\" regex ");
|
||||
let error = capture(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -1290,7 +1289,7 @@ mod tests {
|
||||
);
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("token: header \"Location\" xxx");
|
||||
let mut reader = Reader::new("token: header \"Location\" xxx");
|
||||
let error = capture(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -1310,7 +1309,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_assert() {
|
||||
let mut reader = Reader::init("header \"Location\" equals \"https://google.fr\"");
|
||||
let mut reader = Reader::new("header \"Location\" equals \"https://google.fr\"");
|
||||
let assert0 = assert(&mut reader).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
@ -1337,7 +1336,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_assert_jsonpath() {
|
||||
let mut reader = Reader::init("jsonpath \"$.errors\" equals 5");
|
||||
let mut reader = Reader::new("jsonpath \"$.errors\" equals 5");
|
||||
|
||||
assert_eq!(
|
||||
assert(&mut reader).unwrap().predicate,
|
||||
|
||||
@ -86,7 +86,7 @@ pub fn unquoted_string_key(reader: &mut Reader) -> ParseResult<'static, EncodedS
|
||||
match escape_char(reader) {
|
||||
Ok(c) => {
|
||||
value.push(c);
|
||||
encoded.push_str(reader.from(save.cursor).as_str())
|
||||
encoded.push_str(reader.peek_back(save.cursor).as_str())
|
||||
}
|
||||
Err(e) => {
|
||||
if e.recoverable {
|
||||
@ -104,7 +104,7 @@ pub fn unquoted_string_key(reader: &mut Reader) -> ParseResult<'static, EncodedS
|
||||
|| c == '$'
|
||||
{
|
||||
value.push(c);
|
||||
encoded.push_str(reader.from(save.cursor).as_str())
|
||||
encoded.push_str(reader.peek_back(save.cursor).as_str())
|
||||
} else {
|
||||
reader.state = save;
|
||||
break;
|
||||
@ -237,7 +237,7 @@ pub fn backtick_template(reader: &mut Reader) -> ParseResult<'static, Template>
|
||||
fn any_char(except: Vec<char>, reader: &mut Reader) -> ParseResult<'static, (char, String)> {
|
||||
let start = reader.state.clone();
|
||||
match escape_char(reader) {
|
||||
Ok(c) => Ok((c, reader.from(start.cursor))),
|
||||
Ok(c) => Ok((c, reader.peek_back(start.cursor))),
|
||||
Err(e) => {
|
||||
if e.recoverable {
|
||||
reader.state = start.clone();
|
||||
@ -261,7 +261,7 @@ fn any_char(except: Vec<char>, reader: &mut Reader) -> ParseResult<'static, (cha
|
||||
},
|
||||
})
|
||||
} else {
|
||||
Ok((c, reader.from(start.cursor)))
|
||||
Ok((c, reader.peek_back(start.cursor)))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -332,7 +332,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_empty() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -346,7 +346,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_with_hash() {
|
||||
let mut reader = Reader::init("a#");
|
||||
let mut reader = Reader::new("a#");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -363,7 +363,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_with_encoded_hash() {
|
||||
let mut reader = Reader::init("a\\u{23}");
|
||||
let mut reader = Reader::new("a\\u{23}");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -380,7 +380,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_with_quote() {
|
||||
let mut reader = Reader::init("\"hi\"");
|
||||
let mut reader = Reader::new("\"hi\"");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -397,7 +397,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_hello_world() {
|
||||
let mut reader = Reader::init("hello\\u{20}{{name}}!");
|
||||
let mut reader = Reader::new("hello\\u{20}{{name}}!");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -434,7 +434,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_template_trailing_space() {
|
||||
let mut reader = Reader::init("hello world # comment");
|
||||
let mut reader = Reader::new("hello world # comment");
|
||||
assert_eq!(
|
||||
unquoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -458,7 +458,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_key() {
|
||||
let mut reader = Reader::init("key");
|
||||
let mut reader = Reader::new("key");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -470,7 +470,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
|
||||
let mut reader = Reader::init("key\\u{20}\\u{3a} :");
|
||||
let mut reader = Reader::new("key\\u{20}\\u{3a} :");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -482,7 +482,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 15);
|
||||
|
||||
let mut reader = Reader::init("$top:");
|
||||
let mut reader = Reader::new("$top:");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -497,7 +497,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_key_with_square_bracket() {
|
||||
let mut reader = Reader::init("values\\u{5b}0\\u{5d} :");
|
||||
let mut reader = Reader::new("values\\u{5b}0\\u{5d} :");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -509,7 +509,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 19);
|
||||
|
||||
let mut reader = Reader::init("values[0] :");
|
||||
let mut reader = Reader::new("values[0] :");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -524,7 +524,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_keys_ignore_start_square_bracket() {
|
||||
let mut reader = Reader::init("[0]:");
|
||||
let mut reader = Reader::new("[0]:");
|
||||
let error = unquoted_string_key(&mut reader).err().unwrap();
|
||||
assert!(error.recoverable);
|
||||
assert_eq!(reader.state.cursor, 3);
|
||||
@ -532,7 +532,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_keys_accept_start_escape_square_bracket() {
|
||||
let mut reader = Reader::init("\\u{5b}0\\u{5d}");
|
||||
let mut reader = Reader::new("\\u{5b}0\\u{5d}");
|
||||
assert_eq!(
|
||||
unquoted_string_key(&mut reader).unwrap(),
|
||||
EncodedString {
|
||||
@ -547,7 +547,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unquoted_key_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = unquoted_string_key(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -557,12 +557,12 @@ mod tests {
|
||||
}
|
||||
);
|
||||
|
||||
let mut reader = Reader::init("\\l");
|
||||
let mut reader = Reader::new("\\l");
|
||||
let error = unquoted_string_key(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 2 });
|
||||
assert_eq!(error.inner, ParseError::EscapeChar {});
|
||||
|
||||
let mut reader = Reader::init(r#"{"id":1}"#);
|
||||
let mut reader = Reader::new(r#"{"id":1}"#);
|
||||
let error = unquoted_string_key(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -575,7 +575,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_quoted_template() {
|
||||
let mut reader = Reader::init("\"\"");
|
||||
let mut reader = Reader::new("\"\"");
|
||||
assert_eq!(
|
||||
quoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -586,7 +586,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("\"a#\"");
|
||||
let mut reader = Reader::new("\"a#\"");
|
||||
assert_eq!(
|
||||
quoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -600,7 +600,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
|
||||
let mut reader = Reader::init("\"{0}\"");
|
||||
let mut reader = Reader::new("\"{0}\"");
|
||||
assert_eq!(
|
||||
quoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -618,7 +618,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_quoted_template_with_quote() {
|
||||
// "\"hi\""
|
||||
let mut reader = Reader::init("\"\\\"hi\\\"\"");
|
||||
let mut reader = Reader::new("\"\\\"hi\\\"\"");
|
||||
assert_eq!(
|
||||
quoted_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -635,7 +635,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_quoted_template_error_missing_closing_quote() {
|
||||
let mut reader = Reader::init("\"not found");
|
||||
let mut reader = Reader::new("\"not found");
|
||||
let error = quoted_template(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -649,18 +649,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_quoted_string() {
|
||||
let mut reader = Reader::init("\"\"");
|
||||
let mut reader = Reader::new("\"\"");
|
||||
assert_eq!(quoted_string(&mut reader).unwrap(), "");
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("\"Hello\"");
|
||||
let mut reader = Reader::new("\"Hello\"");
|
||||
assert_eq!(quoted_string(&mut reader).unwrap(), "Hello");
|
||||
assert_eq!(reader.state.cursor, 7);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_backtick_template() {
|
||||
let mut reader = Reader::init("``");
|
||||
let mut reader = Reader::new("``");
|
||||
assert_eq!(
|
||||
backtick_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -671,7 +671,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("`foo#`");
|
||||
let mut reader = Reader::new("`foo#`");
|
||||
assert_eq!(
|
||||
backtick_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -685,7 +685,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("`{0}`");
|
||||
let mut reader = Reader::new("`{0}`");
|
||||
assert_eq!(
|
||||
backtick_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -703,7 +703,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_backtick_template_with_backtick() {
|
||||
// `\`hi\``
|
||||
let mut reader = Reader::init("`\\`hi\\``");
|
||||
let mut reader = Reader::new("`\\`hi\\``");
|
||||
assert_eq!(
|
||||
backtick_template(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -720,7 +720,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_backtick_template_error_missing_closing_backtick() {
|
||||
let mut reader = Reader::init("`not found");
|
||||
let mut reader = Reader::new("`not found");
|
||||
let error = backtick_template(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -734,28 +734,28 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_any_char() {
|
||||
let mut reader = Reader::init("a");
|
||||
let mut reader = Reader::new("a");
|
||||
assert_eq!(
|
||||
any_char(vec![], &mut reader).unwrap(),
|
||||
('a', "a".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init(" ");
|
||||
let mut reader = Reader::new(" ");
|
||||
assert_eq!(
|
||||
any_char(vec![], &mut reader).unwrap(),
|
||||
(' ', " ".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 1);
|
||||
|
||||
let mut reader = Reader::init("\\t");
|
||||
let mut reader = Reader::new("\\t");
|
||||
assert_eq!(
|
||||
any_char(vec![], &mut reader).unwrap(),
|
||||
('\t', "\\t".to_string())
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("#");
|
||||
let mut reader = Reader::new("#");
|
||||
assert_eq!(
|
||||
any_char(vec![], &mut reader).unwrap(),
|
||||
('#', "#".to_string())
|
||||
@ -765,7 +765,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_any_char_quote() {
|
||||
let mut reader = Reader::init("\\\"");
|
||||
let mut reader = Reader::new("\\\"");
|
||||
assert_eq!(
|
||||
any_char(vec![], &mut reader).unwrap(),
|
||||
('"', "\\\"".to_string())
|
||||
@ -775,17 +775,17 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_any_char_error() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = any_char(vec![], &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("#");
|
||||
let mut reader = Reader::new("#");
|
||||
let error = any_char(vec!['#'], &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("\t");
|
||||
let mut reader = Reader::new("\t");
|
||||
let error = any_char(vec![], &mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert!(error.recoverable);
|
||||
@ -793,15 +793,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_escape_char() {
|
||||
let mut reader = Reader::init("\\n");
|
||||
let mut reader = Reader::new("\\n");
|
||||
assert_eq!(escape_char(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 2);
|
||||
|
||||
let mut reader = Reader::init("\\u{0a}");
|
||||
let mut reader = Reader::new("\\u{0a}");
|
||||
assert_eq!(escape_char(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = escape_char(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(
|
||||
@ -816,21 +816,21 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_unicode() {
|
||||
let mut reader = Reader::init("{000a}");
|
||||
let mut reader = Reader::new("{000a}");
|
||||
assert_eq!(unicode(&mut reader).unwrap(), '\n');
|
||||
assert_eq!(reader.state.cursor, 6);
|
||||
|
||||
let mut reader = Reader::init("{E9}");
|
||||
let mut reader = Reader::new("{E9}");
|
||||
assert_eq!(unicode(&mut reader).unwrap(), 'é');
|
||||
assert_eq!(reader.state.cursor, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_hex_value() {
|
||||
let mut reader = Reader::init("20x");
|
||||
let mut reader = Reader::new("20x");
|
||||
assert_eq!(hex_value(&mut reader).unwrap(), 32);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = hex_value(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::HexDigit);
|
||||
@ -841,7 +841,7 @@ mod tests {
|
||||
fn test_quoted_template_benchmark() {
|
||||
// benchmark tests not in stable toolchain yet
|
||||
// Simply log duration for the time-being
|
||||
let mut reader = Reader::init(
|
||||
let mut reader = Reader::new(
|
||||
format!(
|
||||
"\"Hello World!\"{}",
|
||||
(0..10_000_000).map(|_| "X").collect::<String>()
|
||||
|
||||
@ -82,7 +82,7 @@ pub fn templatize(encoded_string: EncodedString) -> ParseResult<'static, Vec<Tem
|
||||
|
||||
State::FirstCloseBracket {} => {
|
||||
if s.as_str() == "}" {
|
||||
let mut reader = Reader::init(encoded.as_str());
|
||||
let mut reader = Reader::new(encoded.as_str());
|
||||
reader.state = ReaderState {
|
||||
cursor: 0,
|
||||
pos: expression_start.unwrap().clone(),
|
||||
|
||||
@ -139,7 +139,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url() {
|
||||
let mut reader = Reader::init("http://google.fr # ");
|
||||
let mut reader = Reader::new("http://google.fr # ");
|
||||
assert_eq!(
|
||||
url(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -156,7 +156,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url2() {
|
||||
let mut reader = Reader::init("http://localhost:8000/cookies/set-session-cookie2-valueA");
|
||||
let mut reader = Reader::new("http://localhost:8000/cookies/set-session-cookie2-valueA");
|
||||
assert_eq!(
|
||||
url(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -175,7 +175,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url_with_expression() {
|
||||
let mut reader = Reader::init("http://{{host}}.fr ");
|
||||
let mut reader = Reader::new("http://{{host}}.fr ");
|
||||
assert_eq!(
|
||||
url(&mut reader).unwrap(),
|
||||
Template {
|
||||
@ -212,7 +212,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url_error_variable() {
|
||||
let mut reader = Reader::init("http://{{host>}}.fr");
|
||||
let mut reader = Reader::new("http://{{host>}}.fr");
|
||||
let error = url(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -233,7 +233,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url_error_missing_delimiter() {
|
||||
let mut reader = Reader::init("http://{{host");
|
||||
let mut reader = Reader::new("http://{{host");
|
||||
let error = url(&mut reader).err().unwrap();
|
||||
assert_eq!(
|
||||
error.pos,
|
||||
@ -253,7 +253,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_url_error_empty() {
|
||||
let mut reader = Reader::init(" # eol");
|
||||
let mut reader = Reader::new(" # eol");
|
||||
let error = url(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::UrlIllegalCharacter(' '));
|
||||
@ -315,7 +315,7 @@ mod tests {
|
||||
];
|
||||
for s in valid_urls {
|
||||
//eprintln!("{}", s);
|
||||
let mut reader = Reader::init(s);
|
||||
let mut reader = Reader::new(s);
|
||||
assert!(url(&mut reader).is_ok());
|
||||
}
|
||||
}
|
||||
|
||||
@ -66,30 +66,30 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_parsing_xml_brute_force_errors() {
|
||||
let mut reader = Reader::init("");
|
||||
let mut reader = Reader::new("");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::Xml {});
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("x");
|
||||
let mut reader = Reader::new("x");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::Xml {});
|
||||
assert!(error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("<<");
|
||||
let mut reader = Reader::new("<<");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::Xml {});
|
||||
assert!(!error.recoverable);
|
||||
|
||||
let mut reader = Reader::init("<users><user /></users");
|
||||
let mut reader = Reader::new("<users><user /></users");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::Xml {});
|
||||
|
||||
let mut reader = Reader::init("<users aa><user /></users");
|
||||
let mut reader = Reader::new("<users aa><user /></users");
|
||||
let error = parse(&mut reader).err().unwrap();
|
||||
assert_eq!(error.pos, Pos { line: 1, column: 1 });
|
||||
assert_eq!(error.inner, ParseError::Xml {});
|
||||
@ -97,14 +97,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_parsing_xml_brute_force() {
|
||||
let mut reader = Reader::init("<users><user /></users>");
|
||||
let mut reader = Reader::new("<users><user /></users>");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
String::from("<users><user /></users>")
|
||||
);
|
||||
assert_eq!(reader.state.cursor, 23);
|
||||
|
||||
let mut reader = Reader::init("<users><user /></users>xx");
|
||||
let mut reader = Reader::new("<users><user /></users>xx");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
String::from("<users><user /></users>")
|
||||
@ -112,7 +112,7 @@ mod tests {
|
||||
assert_eq!(reader.state.cursor, 23);
|
||||
assert_eq!(reader.peek_n(2), String::from("xx"));
|
||||
|
||||
let mut reader = Reader::init("<?xml version=\"1.0\"?><users/>xxx");
|
||||
let mut reader = Reader::new("<?xml version=\"1.0\"?><users/>xxx");
|
||||
assert_eq!(
|
||||
parse(&mut reader).unwrap(),
|
||||
String::from("<?xml version=\"1.0\"?><users/>")
|
||||
|
||||
@ -39,7 +39,7 @@ fn test_echo() {
|
||||
}
|
||||
|
||||
fn parse_json(content: String) -> Result<JsonValue, hurl_core::parser::Error> {
|
||||
let mut reader = hurl_core::parser::Reader::init(content.as_str());
|
||||
let mut reader = hurl_core::parser::Reader::new(content.as_str());
|
||||
hurl_core::parser::parse_json(&mut reader)
|
||||
}
|
||||
|
||||
|
||||
@ -276,7 +276,7 @@ fn test_echo() {
|
||||
//eprintln!("value={:#?}", value);
|
||||
let s = format_value(value);
|
||||
eprintln!("s={s}");
|
||||
let mut reader = Reader::init(s.as_str());
|
||||
let mut reader = Reader::new(s.as_str());
|
||||
let parsed_value = parse_json(&mut reader).unwrap();
|
||||
assert_eq!(format_value(parsed_value), s);
|
||||
|
||||
@ -294,7 +294,7 @@ fn test_parse_files() {
|
||||
let path = p.unwrap().path();
|
||||
println!("parsing json file {}", path.display());
|
||||
let s = fs::read_to_string(path).expect("Something went wrong reading the file");
|
||||
let mut reader = Reader::init(s.as_str());
|
||||
let mut reader = Reader::new(s.as_str());
|
||||
let parsed_value = parse_json(&mut reader).unwrap();
|
||||
|
||||
assert_eq!(format_value(parsed_value), s);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user