arcayr/saphyr-serde
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #13 from dtolnay/clippy

Browse source 
Add clippy to travis build
This commit is contained in:
Chen Yuheng 2016-02-29 12:42:17 +08:00
commit 1d7a32c3c7
7 changed files with 376 additions and 377 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
saphyr/.travis.yml
View file

@ -7,5 +7,13 @@ rust:
env:
global:
- secure: ZUcdcbS8xbpdII9FSPx7VtoVhEkJhWL2Hb75tDlKDHNhfXqmt1NyB9q/2qXJ5Ulp4MnYXwsI8LsDloR6gvdB4xElay3smuF/neGvMjrqcB15/2p0MSQ+kZjMsNB6mlb5kAlm8ahduXIscppmw/V+m5hn3Vo+RQz/Ng+pzv0nc8KEXPMYrfRFg+a7FaeIbRbb8ir9EfflUSqArLq2hbi2WdhM3hFMcCIAUt6DD4x5ubjEg60OnIof5FDu0mXMXzQvUfHWOeYnsNcD/DLyDnm6FuQEzk37M4EB8op2SdBUeQMQ5abR3i2rd//DZpbTTEjud0PseWohGAwTwL2aoFrqs7uYQMx+vcGlOzAyDUm4VemVUa3F2BECdzU5BiujcKOITJEVUYWongld93arQq34FuXG/TO/T1XrerxfG6LTkTkKS5Vz7W8z6Rloa99WrQLJg1ZJP6itEU7G7KsDFVgRhsg7rz4/dV/2+cV4UvIwd4HlGXKCFlH0SClqvM3/7i/qqCD0689SJW6Zip+ly38MXlGy2s/AmReEasXvFer9JkOEIuPa8QTBNAjDlw7bWXi6neQWBIZU1VhZcSssnrVmEFN8fNklShzpw5DyKCv8jPTx2O6Dw8B/LgIK8uo+eaTXiO6zz/T1c/qEdsYslvxPA2D3F+ONpPU7238ykT4eRog=
script:
- |
if [ "$TRAVIS_RUST_VERSION" = nightly ]; then
cargo build --features clippy --verbose
else
cargo build --verbose
fi
- cargo test --verbose
after_script:
- curl http://www.rust-ci.org/artifacts/put?t=$RUSTCI_TOKEN | sh

3
saphyr/Cargo.toml
View file

@ -7,3 +7,6 @@ documentation = "http://chyh1990.github.io/yaml-rust/doc/yaml_rust/"
license = "MIT/Apache-2.0"
description = "The missing YAML 1.2 parser for rust"
repository = "https://github.com/chyh1990/yaml-rust"
[dependencies]
clippy = { version = "^0.*", optional = true }

40
saphyr/src/emitter.rs
View file

@ -114,8 +114,8 @@ impl<'a> YamlEmitter<'a> {
}
fn emit_node(&mut self, node: &Yaml) -> EmitResult {
match node {
&Yaml::Array(ref v) => {
match *node {
Yaml::Array(ref v) => {
if v.is_empty() {
try!(write!(self.writer, "[]"));
Ok(())
@ -124,21 +124,19 @@ impl<'a> YamlEmitter<'a> {
try!(write!(self.writer, "\n"));
}
self.level += 1;
let mut cnt = 0usize;
for x in v {
for (cnt, x) in v.iter().enumerate() {
if cnt > 0 {
try!(write!(self.writer, "\n"));
}
try!(self.write_indent());
try!(write!(self.writer, "- "));
try!(self.emit_node(x));
cnt += 1;
if cnt < v.len() {
try!(write!(self.writer, "\n"));
}
}
self.level -= 1;
Ok(())
}
},
&Yaml::Hash(ref h) => {
Yaml::Hash(ref h) => {
if h.is_empty() {
try!(self.writer.write_str("{}"));
Ok(())
@ -147,32 +145,30 @@ impl<'a> YamlEmitter<'a> {
try!(write!(self.writer, "\n"));
}
self.level += 1;
let mut cnt = 0usize;
for (k, v) in h {
for (cnt, (k, v)) in h.iter().enumerate() {
if cnt > 0 {
try!(write!(self.writer, "\n"));
}
try!(self.write_indent());
match k {
match *k {
// complex key is not supported
&Yaml::Array(_) | &Yaml::Hash(_) => {
Yaml::Array(_) | Yaml::Hash(_) => {
return Err(EmitError::BadHashmapKey);
},
_ => { try!(self.emit_node(k)); }
}
try!(write!(self.writer, ": "));
try!(self.emit_node(v));
cnt += 1;
if cnt < h.len() {
try!(write!(self.writer, "\n"));
}
}
self.level -= 1;
Ok(())
}
},
&Yaml::String(ref v) => {
Yaml::String(ref v) => {
try!(escape_str(self.writer, v));
Ok(())
},
&Yaml::Boolean(v) => {
Yaml::Boolean(v) => {
if v {
try!(self.writer.write_str("true"));
} else {
@ -180,15 +176,15 @@ impl<'a> YamlEmitter<'a> {
}
Ok(())
},
&Yaml::Integer(v) => {
Yaml::Integer(v) => {
try!(write!(self.writer, "{}", v));
Ok(())
},
&Yaml::Real(ref v) => {
Yaml::Real(ref v) => {
try!(write!(self.writer, "{}", v));
Ok(())
},
&Yaml::Null | &Yaml::BadValue => {
Yaml::Null | Yaml::BadValue => {
try!(write!(self.writer, "~"));
Ok(())
},

8
saphyr/src/lib.rs
View file

@ -36,6 +36,12 @@
//!
//! ```
#![cfg_attr(feature="clippy", feature(plugin))]
#![cfg_attr(feature="clippy", plugin(clippy))]
#![cfg_attr(feature="clippy", deny(clippy))]
#![cfg_attr(feature="clippy", warn(cyclomatic_complexity))]
#![cfg_attr(feature="clippy", allow(match_same_arms))]
pub mod yaml;
pub mod scanner;
pub mod parser;
@ -89,7 +95,7 @@ mod tests {
emitter.dump(doc).unwrap();
}
assert!(writer.len() > 0);
assert!(!writer.is_empty());
}
fn try_fail(s: &str) -> Result<Vec<Yaml>, ScanError> {

165
saphyr/src/parser.rs
View file

@ -55,11 +55,11 @@ pub enum Event {
impl Event {
fn empty_scalar() -> Event {
// a null scalar
Event::Scalar("~".to_string(), TScalarStyle::Plain, 0, None)
Event::Scalar("~".to_owned(), TScalarStyle::Plain, 0, None)
}
fn empty_scalar_with_anchor(anchor: usize, tag: TokenType) -> Event {
Event::Scalar("".to_string(), TScalarStyle::Plain, anchor, Some(tag))
Event::Scalar("".to_owned(), TScalarStyle::Plain, anchor, Some(tag))
}
}
@ -179,10 +179,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn load_node<R: EventReceiver>(&mut self, first_ev: &Event, recv: &mut R)
-> Result<(), ScanError> {
match *first_ev {
Event::Alias(..) => {
Ok(())
},
Event::Scalar(..) => {
Event::Alias(..) | Event::Scalar(..) => {
Ok(())
},
Event::SequenceStart(_) => {
@ -270,12 +267,12 @@ impl<T: Iterator<Item=char>> Parser<T> {
let tok = try!(self.peek());
match tok.1 {
TokenType::StreamStartToken(_) => {
TokenType::StreamStart(_) => {
self.state = State::ImplicitDocumentStart;
self.skip();
Ok(Event::StreamStart)
},
_ => return Err(ScanError::new(tok.0,
_ => Err(ScanError::new(tok.0,
"did not find expected <stream-start>")),
}
}
@ -283,26 +280,21 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn document_start(&mut self, implicit: bool) -> ParseResult {
let mut tok = try!(self.peek());
if !implicit {
loop {
match tok.1 {
TokenType::DocumentEndToken => {
self.skip();
tok = try!(self.peek());
},
_ => break
}
while let TokenType::DocumentEnd = tok.1 {
self.skip();
tok = try!(self.peek());
}
}
match tok.1 {
TokenType::StreamEndToken => {
TokenType::StreamEnd => {
self.state = State::End;
self.skip();
return Ok(Event::StreamEnd);
Ok(Event::StreamEnd)
},
TokenType::VersionDirectiveToken(..)
| TokenType::TagDirectiveToken(..)
| TokenType::DocumentStartToken => {
TokenType::VersionDirective(..)
| TokenType::TagDirective(..)
| TokenType::DocumentStart => {
// explicit document
self._explict_document_start()
},
@ -323,14 +315,14 @@ impl<T: Iterator<Item=char>> Parser<T> {
loop {
let tok = try!(self.peek());
match tok.1 {
TokenType::VersionDirectiveToken(_, _) => {
TokenType::VersionDirective(_, _) => {
// XXX parsing with warning according to spec
//if major != 1 || minor > 2 {
// return Err(ScanError::new(tok.0,
// "found incompatible YAML document"));
//}
},
TokenType::TagDirectiveToken(..) => {
TokenType::TagDirective(..) => {
// TODO add tag directive
},
_ => break
@ -344,7 +336,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn _explict_document_start(&mut self) -> ParseResult {
try!(self.parser_process_directives());
let tok = try!(self.peek());
if tok.1 != TokenType::DocumentStartToken {
if tok.1 != TokenType::DocumentStart {
return Err(ScanError::new(tok.0, "did not find expected <document start>"));
}
self.push_state(State::DocumentEnd);
@ -356,11 +348,11 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn document_content(&mut self) -> ParseResult {
let tok = try!(self.peek());
match tok.1 {
TokenType::VersionDirectiveToken(..)
|TokenType::TagDirectiveToken(..)
|TokenType::DocumentStartToken
|TokenType::DocumentEndToken
|TokenType::StreamEndToken => {
TokenType::VersionDirective(..)
|TokenType::TagDirective(..)
|TokenType::DocumentStart
|TokenType::DocumentEnd
|TokenType::StreamEnd => {
self.pop_state();
// empty scalar
Ok(Event::empty_scalar())
@ -376,12 +368,9 @@ impl<T: Iterator<Item=char>> Parser<T> {
let tok = try!(self.peek());
let _start_mark = tok.0;
match tok.1 {
TokenType::DocumentEndToken => {
self.skip();
_implicit = false;
}
_ => {}
if let TokenType::DocumentEnd = tok.1 {
self.skip();
_implicit = false;
}
// TODO tag handling
@ -389,7 +378,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
Ok(Event::DocumentEnd)
}
fn register_anchor(&mut self, name: &String, _: &Marker) -> Result<usize, ScanError> {
fn register_anchor(&mut self, name: &str, _: &Marker) -> Result<usize, ScanError> {
// anchors can be overrided/reused
// if self.anchors.contains_key(name) {
// return Err(ScanError::new(*mark,
@ -397,7 +386,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
// }
let new_id = self.anchor_id;
self.anchor_id += 1;
self.anchors.insert(name.clone(), new_id);
self.anchors.insert(name.to_owned(), new_id);
Ok(new_id)
}
@ -406,7 +395,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
let mut anchor_id = 0;
let mut tag = None;
match tok.1 {
TokenType::AliasToken(name) => {
TokenType::Alias(name) => {
self.pop_state();
self.skip();
match self.anchors.get(&name) {
@ -414,21 +403,21 @@ impl<T: Iterator<Item=char>> Parser<T> {
Some(id) => return Ok(Event::Alias(*id))
}
},
TokenType::AnchorToken(name) => {
TokenType::Anchor(name) => {
anchor_id = try!(self.register_anchor(&name, &tok.0));
self.skip();
tok = try!(self.peek());
if let TokenType::TagToken(_, _) = tok.1 {
if let TokenType::Tag(_, _) = tok.1 {
tag = Some(tok.1);
self.skip();
tok = try!(self.peek());
}
},
TokenType::TagToken(..) => {
TokenType::Tag(..) => {
tag = Some(tok.1);
self.skip();
tok = try!(self.peek());
if let TokenType::AnchorToken(name) = tok.1 {
if let TokenType::Anchor(name) = tok.1 {
anchor_id = try!(self.register_anchor(&name, &tok.0));
self.skip();
tok = try!(self.peek());
@ -437,28 +426,28 @@ impl<T: Iterator<Item=char>> Parser<T> {
_ => {}
}
match tok.1 {
TokenType::BlockEntryToken if indentless_sequence => {
TokenType::BlockEntry if indentless_sequence => {
self.state = State::IndentlessSequenceEntry;
Ok(Event::SequenceStart(anchor_id))
},
TokenType::ScalarToken(style, v) => {
TokenType::Scalar(style, v) => {
self.pop_state();
self.skip();
Ok(Event::Scalar(v, style, anchor_id, tag))
},
TokenType::FlowSequenceStartToken => {
TokenType::FlowSequenceStart => {
self.state = State::FlowSequenceFirstEntry;
Ok(Event::SequenceStart(anchor_id))
},
TokenType::FlowMappingStartToken => {
TokenType::FlowMappingStart => {
self.state = State::FlowMappingFirstKey;
Ok(Event::MappingStart(anchor_id))
},
TokenType::BlockSequenceStartToken if block => {
TokenType::BlockSequenceStart if block => {
self.state = State::BlockSequenceFirstEntry;
Ok(Event::SequenceStart(anchor_id))
},
TokenType::BlockMappingStartToken if block => {
TokenType::BlockMappingStart if block => {
self.state = State::BlockMappingFirstKey;
Ok(Event::MappingStart(anchor_id))
},
@ -472,7 +461,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
fn block_mapping_key(&mut self, first: bool) -> ParseResult {
// skip BlockMappingStartToken
// skip BlockMappingStart
if first {
let _ = try!(self.peek());
//self.marks.push(tok.0);
@ -480,13 +469,13 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
let tok = try!(self.peek());
match tok.1 {
TokenType::KeyToken => {
TokenType::Key => {
self.skip();
let tok = try!(self.peek());
match tok.1 {
TokenType::KeyToken
| TokenType::ValueToken
| TokenType::BlockEndToken
TokenType::Key
| TokenType::Value
| TokenType::BlockEnd
=> {
self.state = State::BlockMappingValue;
// empty scalar
@ -499,11 +488,11 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
},
// XXX(chenyh): libyaml failed to parse spec 1.2, ex8.18
TokenType::ValueToken => {
TokenType::Value => {
self.state = State::BlockMappingValue;
Ok(Event::empty_scalar())
},
TokenType::BlockEndToken => {
TokenType::BlockEnd => {
self.pop_state();
self.skip();
Ok(Event::MappingEnd)
@ -517,11 +506,11 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn block_mapping_value(&mut self) -> ParseResult {
let tok = try!(self.peek());
match tok.1 {
TokenType::ValueToken => {
TokenType::Value => {
self.skip();
let tok = try!(self.peek());
match tok.1 {
TokenType::KeyToken | TokenType::ValueToken | TokenType::BlockEndToken
TokenType::Key | TokenType::Value | TokenType::BlockEnd
=> {
self.state = State::BlockMappingKey;
// empty scalar
@ -548,9 +537,9 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
let mut tok = try!(self.peek());
if tok.1 != TokenType::FlowMappingEndToken {
if tok.1 != TokenType::FlowMappingEnd {
if !first {
if tok.1 == TokenType::FlowEntryToken {
if tok.1 == TokenType::FlowEntry {
self.skip();
tok = try!(self.peek());
} else {
@ -559,13 +548,13 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
}
if tok.1 == TokenType::KeyToken {
if tok.1 == TokenType::Key {
self.skip();
tok = try!(self.peek());
match tok.1 {
TokenType::ValueToken
| TokenType::FlowEntryToken
| TokenType::FlowMappingEndToken => {
TokenType::Value
| TokenType::FlowEntry
| TokenType::FlowMappingEnd => {
self.state = State::FlowMappingValue;
return Ok(Event::empty_scalar());
},
@ -575,10 +564,10 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
}
// XXX libyaml fail ex 7.3, empty key
} else if tok.1 == TokenType::ValueToken {
} else if tok.1 == TokenType::Value {
self.state = State::FlowMappingValue;
return Ok(Event::empty_scalar());
} else if tok.1 != TokenType::FlowMappingEndToken {
} else if tok.1 != TokenType::FlowMappingEnd {
self.push_state(State::FlowMappingEmptyValue);
return self.parse_node(false, false);
}
@ -596,12 +585,12 @@ impl<T: Iterator<Item=char>> Parser<T> {
return Ok(Event::empty_scalar());
}
if tok.1 == TokenType::ValueToken {
if tok.1 == TokenType::Value {
self.skip();
let tok = try!(self.peek());
match tok.1 {
TokenType::FlowEntryToken
| TokenType::FlowMappingEndToken => { },
TokenType::FlowEntry
| TokenType::FlowMappingEnd => { },
_ => {
self.push_state(State::FlowMappingKey);
return self.parse_node(false, false);
@ -614,7 +603,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
fn flow_sequence_entry(&mut self, first: bool) -> ParseResult {
// skip FlowMappingStartToken
// skip FlowMappingStart
if first {
let _ = try!(self.peek());
//self.marks.push(tok.0);
@ -622,12 +611,12 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
let mut tok = try!(self.peek());
match tok.1 {
TokenType::FlowSequenceEndToken => {
TokenType::FlowSequenceEnd => {
self.pop_state();
self.skip();
return Ok(Event::SequenceEnd);
},
TokenType::FlowEntryToken if !first => {
TokenType::FlowEntry if !first => {
self.skip();
tok = try!(self.peek());
},
@ -638,12 +627,12 @@ impl<T: Iterator<Item=char>> Parser<T> {
_ => { /* next */ }
}
match tok.1 {
TokenType::FlowSequenceEndToken => {
TokenType::FlowSequenceEnd => {
self.pop_state();
self.skip();
Ok(Event::SequenceEnd)
},
TokenType::KeyToken => {
TokenType::Key => {
self.state = State::FlowSequenceEntryMappingKey;
self.skip();
Ok(Event::MappingStart(0))
@ -657,7 +646,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
fn indentless_sequence_entry(&mut self) -> ParseResult {
let mut tok = try!(self.peek());
if tok.1 != TokenType::BlockEntryToken {
if tok.1 != TokenType::BlockEntry {
self.pop_state();
return Ok(Event::SequenceEnd);
}
@ -665,10 +654,10 @@ impl<T: Iterator<Item=char>> Parser<T> {
self.skip();
tok = try!(self.peek());
match tok.1 {
TokenType::BlockEntryToken
| TokenType::KeyToken
| TokenType::ValueToken
| TokenType::BlockEndToken => {
TokenType::BlockEntry
| TokenType::Key
| TokenType::Value
| TokenType::BlockEnd => {
self.state = State::IndentlessSequenceEntry;
Ok(Event::empty_scalar())
},
@ -688,17 +677,17 @@ impl<T: Iterator<Item=char>> Parser<T> {
}
let mut tok = try!(self.peek());
match tok.1 {
TokenType::BlockEndToken => {
TokenType::BlockEnd => {
self.pop_state();
self.skip();
Ok(Event::SequenceEnd)
},
TokenType::BlockEntryToken => {
TokenType::BlockEntry => {
self.skip();
tok = try!(self.peek());
match tok.1 {
TokenType::BlockEntryToken
| TokenType::BlockEndToken => {
TokenType::BlockEntry
| TokenType::BlockEnd => {
self.state = State::BlockSequenceEntry;
Ok(Event::empty_scalar())
},
@ -719,9 +708,9 @@ impl<T: Iterator<Item=char>> Parser<T> {
let tok = try!(self.peek());
match tok.1 {
TokenType::ValueToken
| TokenType::FlowEntryToken
| TokenType::FlowSequenceEndToken => {
TokenType::Value
| TokenType::FlowEntry
| TokenType::FlowSequenceEnd => {
self.skip();
self.state = State::FlowSequenceEntryMappingValue;
Ok(Event::empty_scalar())
@ -737,13 +726,13 @@ impl<T: Iterator<Item=char>> Parser<T> {
let tok = try!(self.peek());
match tok.1 {
TokenType::ValueToken => {
TokenType::Value => {
self.skip();
let tok = try!(self.peek());
self.state = State::FlowSequenceEntryMappingValue;
match tok.1 {
TokenType::FlowEntryToken
| TokenType::FlowSequenceEndToken => {
TokenType::FlowEntry
| TokenType::FlowSequenceEnd => {
self.state = State::FlowSequenceEntryMappingEnd;
Ok(Event::empty_scalar())
},

441
saphyr/src/scanner.rs
View file

@ -45,7 +45,7 @@ impl ScanError {
pub fn new(loc: Marker, info: &str) -> ScanError {
ScanError {
mark: loc,
info: info.to_string()
info: info.to_owned()
}
}
}
@ -71,30 +71,30 @@ impl fmt::Display for ScanError {
#[derive(Clone, PartialEq, Debug, Eq)]
pub enum TokenType {
NoToken,
StreamStartToken(TEncoding),
StreamEndToken,
StreamStart(TEncoding),
StreamEnd,
/// major, minor
VersionDirectiveToken(u32, u32),
VersionDirective(u32, u32),
/// handle, prefix
TagDirectiveToken(String, String),
DocumentStartToken,
DocumentEndToken,
BlockSequenceStartToken,
BlockMappingStartToken,
BlockEndToken,
FlowSequenceStartToken,
FlowSequenceEndToken,
FlowMappingStartToken,
FlowMappingEndToken,
BlockEntryToken,
FlowEntryToken,
KeyToken,
ValueToken,
AliasToken(String),
AnchorToken(String),
TagDirective(String, String),
DocumentStart,
DocumentEnd,
BlockSequenceStart,
BlockMappingStart,
BlockEnd,
FlowSequenceStart,
FlowSequenceEnd,
FlowMappingStart,
FlowMappingEnd,
BlockEntry,
FlowEntry,
Key,
Value,
Alias(String),
Anchor(String),
/// handle, suffix
TagToken(String, String),
ScalarToken(TScalarStyle, String)
Tag(String, String),
Scalar(TScalarStyle, String)
}
#[derive(Clone, PartialEq, Debug, Eq)]
@ -233,7 +233,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
}
#[inline(always)]
#[inline]
fn lookahead(&mut self, count: usize) {
if self.buffer.len() >= count {
return;
@ -348,7 +348,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
&& self.buffer[1] == '-'
&& self.buffer[2] == '-'
&& is_blankz(self.buffer[3]) {
try!(self.fetch_document_indicator(TokenType::DocumentStartToken));
try!(self.fetch_document_indicator(TokenType::DocumentStart));
return Ok(());
}
@ -357,17 +357,17 @@ impl<T: Iterator<Item=char>> Scanner<T> {
&& self.buffer[1] == '.'
&& self.buffer[2] == '.'
&& is_blankz(self.buffer[3]) {
try!(self.fetch_document_indicator(TokenType::DocumentEndToken));
try!(self.fetch_document_indicator(TokenType::DocumentEnd));
return Ok(());
}
let c = self.buffer[0];
let nc = self.buffer[1];
match c {
'[' => self.fetch_flow_collection_start(TokenType::FlowSequenceStartToken),
'{' => self.fetch_flow_collection_start(TokenType::FlowMappingStartToken),
']' => self.fetch_flow_collection_end(TokenType::FlowSequenceEndToken),
'}' => self.fetch_flow_collection_end(TokenType::FlowMappingEndToken),
'[' => self.fetch_flow_collection_start(TokenType::FlowSequenceStart),
'{' => self.fetch_flow_collection_start(TokenType::FlowMappingStart),
']' => self.fetch_flow_collection_end(TokenType::FlowSequenceEnd),
'}' => self.fetch_flow_collection_end(TokenType::FlowMappingEnd),
',' => self.fetch_flow_entry(),
'-' if is_blankz(nc) => self.fetch_block_entry(),
'?' if self.flow_level > 0 || is_blankz(nc) => self.fetch_key(),
@ -386,7 +386,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
// plain scalar
'-' if !is_blankz(nc) => self.fetch_plain_scalar(),
':' | '?' if !is_blankz(nc) && self.flow_level == 0 => self.fetch_plain_scalar(),
'%' | '@' | '`' => return Err(ScanError::new(self.mark,
'%' | '@' | '`' => Err(ScanError::new(self.mark,
&format!("unexpected character: `{}'", c))),
_ => self.fetch_plain_scalar(),
}
@ -404,9 +404,8 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.token_available = false;
self.tokens_parsed += 1;
match t.1 {
TokenType::StreamEndToken => self.stream_end_produced = true,
_ => {}
if let TokenType::StreamEnd = t.1 {
self.stream_end_produced = true;
}
Ok(Some(t))
}
@ -473,7 +472,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.indent = -1;
self.stream_start_produced = true;
self.allow_simple_key();
self.tokens.push_back(Token(mark, TokenType::StreamStartToken(TEncoding::Utf8)));
self.tokens.push_back(Token(mark, TokenType::StreamStart(TEncoding::Utf8)));
self.simple_keys.push(SimpleKey::new(Marker::new(0,0,0)));
}
@ -488,7 +487,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
try!(self.remove_simple_key());
self.disallow_simple_key();
self.tokens.push_back(Token(self.mark, TokenType::StreamEndToken));
self.tokens.push_back(Token(self.mark, TokenType::StreamEnd));
Ok(())
}
@ -526,7 +525,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.lookahead(1);
}
// XXX return an empty TagDirective token
Token(start_mark, TokenType::TagDirectiveToken(String::new(), String::new()))
Token(start_mark, TokenType::TagDirective(String::new(), String::new()))
// return Err(ScanError::new(start_mark,
// "while scanning a directive, found unknown directive name"))
}
@ -578,7 +577,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
let minor = try!(self.scan_version_directive_number(mark));
Ok(Token(*mark, TokenType::VersionDirectiveToken(major, minor)))
Ok(Token(*mark, TokenType::VersionDirective(major, minor)))
}
fn scan_directive_name(&mut self) -> Result<String, ScanError> {
@ -652,7 +651,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
Err(ScanError::new(*mark,
"while scanning TAG, did not find expected whitespace or line break"))
} else {
Ok(Token(*mark, TokenType::TagDirectiveToken(handle, prefix)))
Ok(Token(*mark, TokenType::TagDirective(handle, prefix)))
}
}
@ -697,12 +696,12 @@ impl<T: Iterator<Item=char>> Scanner<T> {
suffix = try!(self.scan_tag_uri(false, secondary, &String::new(), &start_mark));
} else {
suffix = try!(self.scan_tag_uri(false, false, &handle, &start_mark));
handle = "!".to_string();
handle = "!".to_owned();
// A special case: the '!' tag. Set the handle to '' and the
// suffix to '!'.
if suffix.len() == 0 {
if suffix.is_empty() {
handle.clear();
suffix = "!".to_string();
suffix = "!".to_owned();
}
}
}
@ -710,7 +709,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.lookahead(1);
if is_blankz(self.ch()) {
// XXX: ex 7.2, an empty scalar can follow a secondary tag
Ok(Token(start_mark, TokenType::TagToken(handle, suffix)))
Ok(Token(start_mark, TokenType::Tag(handle, suffix)))
} else {
Err(ScanError::new(start_mark,
"while scanning a tag, did not find expected whitespace or line break"))
@ -739,20 +738,18 @@ impl<T: Iterator<Item=char>> Scanner<T> {
if self.ch() == '!' {
string.push(self.ch());
self.skip();
} else {
} else if directive && string != "!" {
// It's either the '!' tag or not really a tag handle. If it's a %TAG
// directive, it's an error. If it's a tag token, it must be a part of
// URI.
if directive && string != "!" {
return Err(ScanError::new(*mark,
"while parsing a tag directive, did not find expected '!'"));
}
return Err(ScanError::new(*mark,
"while parsing a tag directive, did not find expected '!'"));
}
Ok(string)
}
fn scan_tag_uri(&mut self, directive: bool, _is_secondary: bool,
head: &String, mark: &Marker) -> Result<String, ScanError> {
head: &str, mark: &Marker) -> Result<String, ScanError> {
let mut length = head.len();
let mut string = String::new();
@ -883,9 +880,9 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
if alias {
Ok(Token(start_mark, TokenType::AliasToken(string)))
Ok(Token(start_mark, TokenType::Alias(string)))
} else {
Ok(Token(start_mark, TokenType::AnchorToken(string)))
Ok(Token(start_mark, TokenType::Anchor(string)))
}
}
@ -924,7 +921,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
let start_mark = self.mark;
self.skip();
self.tokens.push_back(Token(start_mark, TokenType::FlowEntryToken));
self.tokens.push_back(Token(start_mark, TokenType::FlowEntry));
Ok(())
}
@ -949,7 +946,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
let mark = self.mark;
// generate BLOCK-SEQUENCE-START if indented
self.roll_indent(mark.col, None, TokenType::BlockSequenceStartToken, mark);
self.roll_indent(mark.col, None, TokenType::BlockSequenceStart, mark);
} else {
// - * only allowed in block
unreachable!();
@ -960,7 +957,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
let start_mark = self.mark;
self.skip();
self.tokens.push_back(Token(start_mark, TokenType::BlockEntryToken));
self.tokens.push_back(Token(start_mark, TokenType::BlockEntry));
Ok(())
}
@ -1119,9 +1116,9 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
if literal {
Ok(Token(start_mark, TokenType::ScalarToken(TScalarStyle::Literal, string)))
Ok(Token(start_mark, TokenType::Scalar(TScalarStyle::Literal, string)))
} else {
Ok(Token(start_mark, TokenType::ScalarToken(TScalarStyle::Foled, string)))
Ok(Token(start_mark, TokenType::Scalar(TScalarStyle::Foled, string)))
}
}
@ -1353,9 +1350,9 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.skip();
if single {
Ok(Token(start_mark, TokenType::ScalarToken(TScalarStyle::SingleQuoted, string)))
Ok(Token(start_mark, TokenType::Scalar(TScalarStyle::SingleQuoted, string)))
} else {
Ok(Token(start_mark, TokenType::ScalarToken(TScalarStyle::DoubleQuoted, string)))
Ok(Token(start_mark, TokenType::Scalar(TScalarStyle::DoubleQuoted, string)))
}
}
@ -1477,7 +1474,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
self.allow_simple_key();
}
Ok(Token(start_mark, TokenType::ScalarToken(TScalarStyle::Plain, string)))
Ok(Token(start_mark, TokenType::Scalar(TScalarStyle::Plain, string)))
}
fn fetch_key(&mut self) -> ScanResult {
@ -1488,7 +1485,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
return Err(ScanError::new(self.mark, "mapping keys are not allowed in this context"));
}
self.roll_indent(start_mark.col, None,
TokenType::BlockMappingStartToken, start_mark);
TokenType::BlockMappingStart, start_mark);
}
try!(self.remove_simple_key());
@ -1500,7 +1497,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
self.skip();
self.tokens.push_back(Token(start_mark, TokenType::KeyToken));
self.tokens.push_back(Token(start_mark, TokenType::Key));
Ok(())
}
@ -1509,13 +1506,13 @@ impl<T: Iterator<Item=char>> Scanner<T> {
let start_mark = self.mark;
if sk.possible {
// insert simple key
let tok = Token(sk.mark, TokenType::KeyToken);
let tok = Token(sk.mark, TokenType::Key);
let tokens_parsed = self.tokens_parsed;
self.insert_token(sk.token_number - tokens_parsed, tok);
// Add the BLOCK-MAPPING-START token if needed.
self.roll_indent(sk.mark.col, Some(sk.token_number),
TokenType::BlockMappingStartToken, start_mark);
TokenType::BlockMappingStart, start_mark);
self.simple_keys.last_mut().unwrap().possible = false;
self.disallow_simple_key();
@ -1528,7 +1525,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
self.roll_indent(start_mark.col, None,
TokenType::BlockMappingStartToken, start_mark);
TokenType::BlockMappingStart, start_mark);
}
if self.flow_level == 0 {
@ -1538,7 +1535,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
}
}
self.skip();
self.tokens.push_back(Token(start_mark, TokenType::ValueToken));
self.tokens.push_back(Token(start_mark, TokenType::Value));
Ok(())
}
@ -1565,7 +1562,7 @@ impl<T: Iterator<Item=char>> Scanner<T> {
return;
}
while self.indent > col {
self.tokens.push_back(Token(self.mark, TokenType::BlockEndToken));
self.tokens.push_back(Token(self.mark, TokenType::BlockEnd));
self.indent = self.indents.pop().unwrap();
}
}
@ -1588,10 +1585,8 @@ impl<T: Iterator<Item=char>> Scanner<T> {
fn remove_simple_key(&mut self) -> ScanResult {
let last = self.simple_keys.last_mut().unwrap();
if last.possible {
if last.required {
return Err(ScanError::new(self.mark, "simple key expected"));
}
if last.possible && last.required {
return Err(ScanError::new(self.mark, "simple key expected"));
}
last.possible = false;
@ -1620,7 +1615,7 @@ macro_rules! next_scalar {
($p:ident, $tk:expr, $v:expr) => {{
let tok = $p.next().unwrap();
match tok.1 {
ScalarToken(style, ref v) => {
Scalar(style, ref v) => {
assert_eq!(style, $tk);
assert_eq!(v, $v);
},
@ -1640,8 +1635,8 @@ macro_rules! end {
fn test_empty() {
let s = "";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, StreamEndToken);
next!(p, StreamStart(..));
next!(p, StreamEnd);
end!(p);
}
@ -1649,9 +1644,9 @@ macro_rules! end {
fn test_scalar() {
let s = "a scalar";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, StreamEndToken);
next!(p, StreamStart(..));
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, StreamEnd);
end!(p);
}
@ -1663,11 +1658,11 @@ macro_rules! end {
...
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, DocumentStartToken);
next!(p, ScalarToken(TScalarStyle::SingleQuoted, _));
next!(p, DocumentEndToken);
next!(p, StreamEndToken);
next!(p, StreamStart(..));
next!(p, DocumentStart);
next!(p, Scalar(TScalarStyle::SingleQuoted, _));
next!(p, DocumentEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1682,13 +1677,13 @@ macro_rules! end {
'a scalar'
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, ScalarToken(TScalarStyle::SingleQuoted, _));
next!(p, DocumentStartToken);
next!(p, ScalarToken(TScalarStyle::SingleQuoted, _));
next!(p, DocumentStartToken);
next!(p, ScalarToken(TScalarStyle::SingleQuoted, _));
next!(p, StreamEndToken);
next!(p, StreamStart(..));
next!(p, Scalar(TScalarStyle::SingleQuoted, _));
next!(p, DocumentStart);
next!(p, Scalar(TScalarStyle::SingleQuoted, _));
next!(p, DocumentStart);
next!(p, Scalar(TScalarStyle::SingleQuoted, _));
next!(p, StreamEnd);
end!(p);
}
@ -1696,15 +1691,15 @@ macro_rules! end {
fn test_a_flow_sequence() {
let s = "[item 1, item 2, item 3]";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, FlowSequenceStartToken);
next!(p, StreamStart(..));
next!(p, FlowSequenceStart);
next_scalar!(p, TScalarStyle::Plain, "item 1");
next!(p, FlowEntryToken);
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, FlowEntryToken);
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, FlowSequenceEndToken);
next!(p, StreamEndToken);
next!(p, FlowEntry);
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, FlowEntry);
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, FlowSequenceEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1718,20 +1713,20 @@ macro_rules! end {
}
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, FlowMappingStartToken);
next!(p, KeyToken);
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, ValueToken);
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, FlowEntryToken);
next!(p, KeyToken);
next!(p, StreamStart(..));
next!(p, FlowMappingStart);
next!(p, Key);
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, Value);
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, FlowEntry);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "a complex key");
next!(p, ValueToken);
next!(p, ScalarToken(TScalarStyle::Plain, _));
next!(p, FlowEntryToken);
next!(p, FlowMappingEndToken);
next!(p, StreamEndToken);
next!(p, Value);
next!(p, Scalar(TScalarStyle::Plain, _));
next!(p, FlowEntry);
next!(p, FlowMappingEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1749,32 +1744,32 @@ macro_rules! end {
key 2: value 2
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, StreamStart(..));
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 2");
next!(p, BlockEntryToken);
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 3.1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 3.2");
next!(p, BlockEndToken);
next!(p, BlockEntryToken);
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, BlockEnd);
next!(p, BlockEntry);
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 1");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 1");
next!(p, KeyToken);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 2");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 2");
next!(p, BlockEndToken);
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, BlockEnd);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1793,40 +1788,40 @@ a sequence:
- item 2
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken);
next!(p, ScalarToken(_, _));
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken);
next!(p, ScalarToken(_, _));
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken); // libyaml comment seems to be wrong
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken);
next!(p, ScalarToken(_, _));
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken);
next!(p, ScalarToken(_, _));
next!(p, BlockEndToken);
next!(p, KeyToken);
next!(p, ScalarToken(_, _));
next!(p, ValueToken);
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, ScalarToken(_, _));
next!(p, BlockEntryToken);
next!(p, ScalarToken(_, _));
next!(p, BlockEndToken);
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, StreamStart(..));
next!(p, BlockMappingStart);
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value);
next!(p, Scalar(_, _));
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value);
next!(p, Scalar(_, _));
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value); // libyaml comment seems to be wrong
next!(p, BlockMappingStart);
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value);
next!(p, Scalar(_, _));
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value);
next!(p, Scalar(_, _));
next!(p, BlockEnd);
next!(p, Key);
next!(p, Scalar(_, _));
next!(p, Value);
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next!(p, Scalar(_, _));
next!(p, BlockEntry);
next!(p, Scalar(_, _));
next!(p, BlockEnd);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1840,17 +1835,17 @@ key:
- item 2
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, StreamStart(..));
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key");
next!(p, ValueToken);
next!(p, BlockEntryToken);
next!(p, Value);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 2");
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1866,35 +1861,35 @@ key:
: complex value
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, StreamStart(..));
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 2");
next!(p, BlockEndToken);
next!(p, BlockEntryToken);
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, BlockEnd);
next!(p, BlockEntry);
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 1");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 1");
next!(p, KeyToken);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 2");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 2");
next!(p, BlockEndToken);
next!(p, BlockEntryToken);
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, BlockEnd);
next!(p, BlockEntry);
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "complex key");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "complex value");
next!(p, BlockEndToken);
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, BlockEnd);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1910,32 +1905,32 @@ key:
key 2: value 2
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, StreamStart(..));
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "a sequence");
next!(p, ValueToken);
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, Value);
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "item 2");
next!(p, BlockEndToken);
next!(p, KeyToken);
next!(p, BlockEnd);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "a mapping");
next!(p, ValueToken);
next!(p, BlockMappingStartToken);
next!(p, KeyToken);
next!(p, Value);
next!(p, BlockMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 1");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 1");
next!(p, KeyToken);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "key 2");
next!(p, ValueToken);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "value 2");
next!(p, BlockEndToken);
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, BlockEnd);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1949,17 +1944,17 @@ key:
}
";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, FlowMappingStartToken);
next!(p, KeyToken);
next!(p, StreamStart(..));
next!(p, FlowMappingStart);
next!(p, Key);
next_scalar!(p, TScalarStyle::Plain, "foo");
next!(p, ValueToken);
next!(p, FlowEntryToken);
next!(p, ValueToken);
next!(p, Value);
next!(p, FlowEntry);
next!(p, Value);
next_scalar!(p, TScalarStyle::Plain, "bar");
next!(p, FlowEntryToken);
next!(p, FlowMappingEndToken);
next!(p, StreamEndToken);
next!(p, FlowEntry);
next!(p, FlowMappingEnd);
next!(p, StreamEnd);
end!(p);
}
@ -1967,15 +1962,15 @@ key:
fn test_scanner_cr() {
let s = "---\r\n- tok1\r\n- tok2";
let mut p = Scanner::new(s.chars());
next!(p, StreamStartToken(..));
next!(p, DocumentStartToken);
next!(p, BlockSequenceStartToken);
next!(p, BlockEntryToken);
next!(p, StreamStart(..));
next!(p, DocumentStart);
next!(p, BlockSequenceStart);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "tok1");
next!(p, BlockEntryToken);
next!(p, BlockEntry);
next_scalar!(p, TScalarStyle::Plain, "tok2");
next!(p, BlockEndToken);
next!(p, StreamEndToken);
next!(p, BlockEnd);
next!(p, StreamEnd);
end!(p);
}

88
saphyr/src/yaml.rs
View file

@ -94,46 +94,43 @@ impl EventReceiver for YamlLoader {
Event::Scalar(ref v, style, aid, ref tag) => {
let node = if style != TScalarStyle::Plain {
Yaml::String(v.clone())
} else {
match tag {
&Some(TokenType::TagToken(ref handle, ref suffix)) => {
// XXX tag:yaml.org,2002:
if handle == "!!" {
match suffix.as_ref() {
"bool" => {
// "true" or "false"
match v.parse::<bool>() {
Err(_) => Yaml::BadValue,
Ok(v) => Yaml::Boolean(v)
}
},
"int" => {
match v.parse::<i64>() {
Err(_) => Yaml::BadValue,
Ok(v) => Yaml::Integer(v)
}
},
"float" => {
match v.parse::<f64>() {
Err(_) => Yaml::BadValue,
Ok(_) => Yaml::Real(v.clone())
}
},
"null" => {
match v.as_ref() {
"~" | "null" => Yaml::Null,
_ => Yaml::BadValue,
}
}
_ => Yaml::String(v.clone()),
} else if let Some(TokenType::Tag(ref handle, ref suffix)) = *tag {
// XXX tag:yaml.org,2002:
if handle == "!!" {
match suffix.as_ref() {
"bool" => {
// "true" or "false"
match v.parse::<bool>() {
Err(_) => Yaml::BadValue,
Ok(v) => Yaml::Boolean(v)
}
},
"int" => {
match v.parse::<i64>() {
Err(_) => Yaml::BadValue,
Ok(v) => Yaml::Integer(v)
}
},
"float" => {
match v.parse::<f64>() {
Err(_) => Yaml::BadValue,
Ok(_) => Yaml::Real(v.clone())
}
},
"null" => {
match v.as_ref() {
"~" | "null" => Yaml::Null,
_ => Yaml::BadValue,
}
} else {
Yaml::String(v.clone())
}
},
// Datatype is not specified, or unrecognized
_ => { Yaml::from_str(v.as_ref()) }
_ => Yaml::String(v.clone()),
}
} else {
Yaml::String(v.clone())
}
} else {
// Datatype is not specified, or unrecognized
Yaml::from_str(v.as_ref())
};
self.insert_new_node((node, aid));
@ -245,7 +242,12 @@ impl Yaml {
_ => None
}
}
}
#[cfg_attr(feature="clippy", allow(should_implement_trait))]
impl Yaml {
// Not implementing FromStr because there is no possibility of Error.
// This function falls back to Yaml::String if nothing else matches.
pub fn from_str(v: &str) -> Yaml {
if v.starts_with("0x") {
let n = i64::from_str_radix(&v[2..], 16);
@ -259,8 +261,8 @@ impl Yaml {
return Yaml::Integer(n.unwrap());
}
}
if v.starts_with("+") && v[1..].parse::<i64>().is_ok() {
return Yaml::Integer(v[1..].parse::<i64>().unwrap());
if v.starts_with('+') && v[1..].parse::<i64>().is_ok() {
return Yaml::Integer(v[1..].parse::<i64>().unwrap());
}
match v {
"~" | "null" => Yaml::Null,
@ -268,8 +270,8 @@ impl Yaml {
"false" => Yaml::Boolean(false),
_ if v.parse::<i64>().is_ok() => Yaml::Integer(v.parse::<i64>().unwrap()),
// try parsing as f64
_ if v.parse::<f64>().is_ok() => Yaml::Real(v.to_string()),
_ => Yaml::String(v.to_string())
_ if v.parse::<f64>().is_ok() => Yaml::Real(v.to_owned()),
_ => Yaml::String(v.to_owned())
}
}
}
@ -279,7 +281,7 @@ impl<'a> Index<&'a str> for Yaml {
type Output = Yaml;
fn index(&self, idx: &'a str) -> &Yaml {
let key = Yaml::String(idx.to_string());
let key = Yaml::String(idx.to_owned());
match self.as_hash() {
Some(h) => h.get(&key).unwrap_or(&BAD_VALUE),
None => &BAD_VALUE
@ -333,7 +335,7 @@ a4:
a5: 'single_quoted'
a6: \"double_quoted\"
a7: 你好
".to_string();
".to_owned();
let out = YamlLoader::load_from_str(&s).unwrap();
let doc = &out[0];
assert_eq!(doc["a7"].as_str().unwrap(), "你好");