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: env:
global: 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= - 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: after_script:
- curl http://www.rust-ci.org/artifacts/put?t=$RUSTCI_TOKEN | sh - 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" license = "MIT/Apache-2.0"
description = "The missing YAML 1.2 parser for rust" description = "The missing YAML 1.2 parser for rust"
repository = "https://github.com/chyh1990/yaml-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 { fn emit_node(&mut self, node: &Yaml) -> EmitResult {
match node { match *node {
&Yaml::Array(ref v) => { Yaml::Array(ref v) => {
if v.is_empty() { if v.is_empty() {
try!(write!(self.writer, "[]")); try!(write!(self.writer, "[]"));
Ok(()) Ok(())
@ -124,21 +124,19 @@ impl<'a> YamlEmitter<'a> {
try!(write!(self.writer, "\n")); try!(write!(self.writer, "\n"));
} }
self.level += 1; self.level += 1;
let mut cnt = 0usize; for (cnt, x) in v.iter().enumerate() {
for x in v { if cnt > 0 {
try!(write!(self.writer, "\n"));
}
try!(self.write_indent()); try!(self.write_indent());
try!(write!(self.writer, "- ")); try!(write!(self.writer, "- "));
try!(self.emit_node(x)); try!(self.emit_node(x));
cnt += 1;
if cnt < v.len() {
try!(write!(self.writer, "\n"));
}
} }
self.level -= 1; self.level -= 1;
Ok(()) Ok(())
} }
}, },
&Yaml::Hash(ref h) => { Yaml::Hash(ref h) => {
if h.is_empty() { if h.is_empty() {
try!(self.writer.write_str("{}")); try!(self.writer.write_str("{}"));
Ok(()) Ok(())
@ -147,32 +145,30 @@ impl<'a> YamlEmitter<'a> {
try!(write!(self.writer, "\n")); try!(write!(self.writer, "\n"));
} }
self.level += 1; self.level += 1;
let mut cnt = 0usize; for (cnt, (k, v)) in h.iter().enumerate() {
for (k, v) in h { if cnt > 0 {
try!(write!(self.writer, "\n"));
}
try!(self.write_indent()); try!(self.write_indent());
match k { match *k {
// complex key is not supported // complex key is not supported
&Yaml::Array(_) | &Yaml::Hash(_) => { Yaml::Array(_) | Yaml::Hash(_) => {
return Err(EmitError::BadHashmapKey); return Err(EmitError::BadHashmapKey);
}, },
_ => { try!(self.emit_node(k)); } _ => { try!(self.emit_node(k)); }
} }
try!(write!(self.writer, ": ")); try!(write!(self.writer, ": "));
try!(self.emit_node(v)); try!(self.emit_node(v));
cnt += 1;
if cnt < h.len() {
try!(write!(self.writer, "\n"));
}
} }
self.level -= 1; self.level -= 1;
Ok(()) Ok(())
} }
}, },
&Yaml::String(ref v) => { Yaml::String(ref v) => {
try!(escape_str(self.writer, v)); try!(escape_str(self.writer, v));
Ok(()) Ok(())
}, },
&Yaml::Boolean(v) => { Yaml::Boolean(v) => {
if v { if v {
try!(self.writer.write_str("true")); try!(self.writer.write_str("true"));
} else { } else {
@ -180,15 +176,15 @@ impl<'a> YamlEmitter<'a> {
} }
Ok(()) Ok(())
}, },
&Yaml::Integer(v) => { Yaml::Integer(v) => {
try!(write!(self.writer, "{}", v)); try!(write!(self.writer, "{}", v));
Ok(()) Ok(())
}, },
&Yaml::Real(ref v) => { Yaml::Real(ref v) => {
try!(write!(self.writer, "{}", v)); try!(write!(self.writer, "{}", v));
Ok(()) Ok(())
}, },
&Yaml::Null | &Yaml::BadValue => { Yaml::Null | Yaml::BadValue => {
try!(write!(self.writer, "~")); try!(write!(self.writer, "~"));
Ok(()) 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 yaml;
pub mod scanner; pub mod scanner;
pub mod parser; pub mod parser;
@ -89,7 +95,7 @@ mod tests {
emitter.dump(doc).unwrap(); emitter.dump(doc).unwrap();
} }
assert!(writer.len() > 0); assert!(!writer.is_empty());
} }
fn try_fail(s: &str) -> Result<Vec<Yaml>, ScanError> { fn try_fail(s: &str) -> Result<Vec<Yaml>, ScanError> {

157
saphyr/src/parser.rs
View file

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

435
saphyr/src/scanner.rs
View file

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

24
saphyr/src/yaml.rs
View file

@ -94,9 +94,7 @@ impl EventReceiver for YamlLoader {
Event::Scalar(ref v, style, aid, ref tag) => { Event::Scalar(ref v, style, aid, ref tag) => {
let node = if style != TScalarStyle::Plain { let node = if style != TScalarStyle::Plain {
Yaml::String(v.clone()) Yaml::String(v.clone())
} else { } else if let Some(TokenType::Tag(ref handle, ref suffix)) = *tag {
match tag {
&Some(TokenType::TagToken(ref handle, ref suffix)) => {
// XXX tag:yaml.org,2002: // XXX tag:yaml.org,2002:
if handle == "!!" { if handle == "!!" {
match suffix.as_ref() { match suffix.as_ref() {
@ -130,10 +128,9 @@ impl EventReceiver for YamlLoader {
} else { } else {
Yaml::String(v.clone()) Yaml::String(v.clone())
} }
}, } else {
// Datatype is not specified, or unrecognized // Datatype is not specified, or unrecognized
_ => { Yaml::from_str(v.as_ref()) } Yaml::from_str(v.as_ref())
}
}; };
self.insert_new_node((node, aid)); self.insert_new_node((node, aid));
@ -245,7 +242,12 @@ impl Yaml {
_ => None _ => 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 { pub fn from_str(v: &str) -> Yaml {
if v.starts_with("0x") { if v.starts_with("0x") {
let n = i64::from_str_radix(&v[2..], 16); let n = i64::from_str_radix(&v[2..], 16);
@ -259,7 +261,7 @@ impl Yaml {
return Yaml::Integer(n.unwrap()); return Yaml::Integer(n.unwrap());
} }
} }
if v.starts_with("+") && v[1..].parse::<i64>().is_ok() { if v.starts_with('+') && v[1..].parse::<i64>().is_ok() {
return Yaml::Integer(v[1..].parse::<i64>().unwrap()); return Yaml::Integer(v[1..].parse::<i64>().unwrap());
} }
match v { match v {
@ -268,8 +270,8 @@ impl Yaml {
"false" => Yaml::Boolean(false), "false" => Yaml::Boolean(false),
_ if v.parse::<i64>().is_ok() => Yaml::Integer(v.parse::<i64>().unwrap()), _ if v.parse::<i64>().is_ok() => Yaml::Integer(v.parse::<i64>().unwrap()),
// try parsing as f64 // try parsing as f64
_ if v.parse::<f64>().is_ok() => Yaml::Real(v.to_string()), _ if v.parse::<f64>().is_ok() => Yaml::Real(v.to_owned()),
_ => Yaml::String(v.to_string()) _ => Yaml::String(v.to_owned())
} }
} }
} }
@ -279,7 +281,7 @@ impl<'a> Index<&'a str> for Yaml {
type Output = Yaml; type Output = Yaml;
fn index(&self, idx: &'a str) -> &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() { match self.as_hash() {
Some(h) => h.get(&key).unwrap_or(&BAD_VALUE), Some(h) => h.get(&key).unwrap_or(&BAD_VALUE),
None => &BAD_VALUE None => &BAD_VALUE
@ -333,7 +335,7 @@ a4:
a5: 'single_quoted' a5: 'single_quoted'
a6: \"double_quoted\" a6: \"double_quoted\"
a7: 你好 a7: 你好
".to_string(); ".to_owned();
let out = YamlLoader::load_from_str(&s).unwrap(); let out = YamlLoader::load_from_str(&s).unwrap();
let doc = &out[0]; let doc = &out[0];
assert_eq!(doc["a7"].as_str().unwrap(), "你好"); assert_eq!(doc["a7"].as_str().unwrap(), "你好");