From 3fa9a24739876c327a875a6a701136be32dd45e5 Mon Sep 17 00:00:00 2001 From: Hendrik Sollich Date: Mon, 22 May 2017 19:30:01 +0200 Subject: [PATCH 1/5] quoting possible booleans fixes #53 --- parser/Cargo.toml | 2 +- parser/src/emitter.rs | 58 +++++++++++++++++++++++++++++++++++-------- 2 files changed, 48 insertions(+), 12 deletions(-) diff --git a/parser/Cargo.toml b/parser/Cargo.toml index 0c79598..a4e2fda 100644 --- a/parser/Cargo.toml +++ b/parser/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "yaml-rust" -version = "0.3.5" +version = "0.3.6" authors = ["Yuheng Chen "] homepage = "http://chyh1990.github.io/yaml-rust/" documentation = "http://chyh1990.github.io/yaml-rust/doc/yaml_rust/" diff --git a/parser/src/emitter.rs b/parser/src/emitter.rs index 45f2024..91c94b2 100644 --- a/parser/src/emitter.rs +++ b/parser/src/emitter.rs @@ -137,15 +137,12 @@ impl<'a> YamlEmitter<'a> { Yaml::Array(ref v) => { try!(write!(self.writer, "[")); if self.level >= 0 { - try!(write!(self.writer, "+ ")); + try!(write!(self.writer, "")); } - self.level += 1; for (cnt, x) in v.iter().enumerate() { - try!(self.write_indent()); if cnt > 0 { try!(write!(self.writer, ", ")); } try!(self.emit_node(x)); } - self.level -= 1; try!(write!(self.writer, "]")); Ok(()) }, @@ -181,8 +178,7 @@ impl<'a> YamlEmitter<'a> { Yaml::String(ref v) => { if need_quotes(v) { try!(escape_str(self.writer, v)); - } - else { + } else { try!(write!(self.writer, "{}", v)); } Ok(()) @@ -306,10 +302,13 @@ fn need_quotes(string: &str) -> bool { _ => false, } }) - || string == "true" - || string == "false" - || string == "null" - || string == "~" + || [// http://yaml.org/type/bool.html + "y","Y","yes","Yes","YES","n","N","no","No","NO", + "True", "TRUE", "true", "False", "FALSE", "false", + "on","On","ON","off","Off","OFF", + // http://yaml.org/type/null.html + "null","Null","NULL", "~" + ].contains(&string) || string.starts_with('.') || string.parse::().is_ok() || string.parse::().is_ok() @@ -421,7 +420,8 @@ products: "true": bool key "{}": empty hash key x: test -y: string with spaces"#; +"y": "can't avoid quoting here" +z: string with spaces"#; let docs = YamlLoader::load_from_str(&s).unwrap(); let doc = &docs[0]; @@ -434,6 +434,42 @@ y: string with spaces"#; assert_eq!(s, writer, "actual:\n\n{}\n", writer); } + #[test] + fn emit_quoted_bools() { + let input = r#"--- +string0: yes +string1: no +string2: "true" +string3: "false" +string4: "~" +null0: ~ +[true, false]: real_bools +[True, TRUE, False, FALSE, y,Y,yes,Yes,YES,n,N,no,No,NO,on,On,ON,off,Off,OFF]: false_bools +bool0: true +bool1: false"#; + let expected = r#"--- +string0: "yes" +string1: "no" +string2: "true" +string3: "false" +string4: "~" +null0: ~ +[true, false]: real_bools +["True", "TRUE", "False", "FALSE", "y", "Y", "yes", "Yes", "YES", "n", "N", "no", "No", "NO", "on", "On", "ON", "off", "Off", "OFF"]: false_bools +bool0: true +bool1: false"#; + + let docs = YamlLoader::load_from_str(&input).unwrap(); + let doc = &docs[0]; + let mut writer = String::new(); + { + let mut emitter = YamlEmitter::new(&mut writer); + emitter.dump(doc).unwrap(); + } + + assert_eq!(expected, writer, "actual:\n\n{}\n", writer); + } + #[test] fn test_empty_and_nested() { let s = r#"--- From 083df3ce4c8f23eddfe58b809bac0da8fe60ba0f Mon Sep 17 00:00:00 2001 From: Hendrik Sollich Date: Sat, 10 Jun 2017 23:39:07 +0200 Subject: [PATCH 2/5] correctly emitting nested arrays fixed #70 too --- parser/src/emitter.rs | 111 +++++++++++++++++++++++------------------- parser/src/yaml.rs | 7 +++ 2 files changed, 69 insertions(+), 49 deletions(-) diff --git a/parser/src/emitter.rs b/parser/src/emitter.rs index 91c94b2..c7bc154 100644 --- a/parser/src/emitter.rs +++ b/parser/src/emitter.rs @@ -134,39 +134,8 @@ impl<'a> YamlEmitter<'a> { fn emit_node_compact(&mut self, node: &Yaml) -> EmitResult { match *node { - Yaml::Array(ref v) => { - try!(write!(self.writer, "[")); - if self.level >= 0 { - try!(write!(self.writer, "")); - } - for (cnt, x) in v.iter().enumerate() { - if cnt > 0 { try!(write!(self.writer, ", ")); } - try!(self.emit_node(x)); - } - try!(write!(self.writer, "]")); - Ok(()) - }, - Yaml::Hash(ref h) => { - try!(self.writer.write_str("{")); - self.level += 1; - for (cnt, (k, v)) in h.iter().enumerate() { - if cnt > 0 { - try!(write!(self.writer, ", ")); - } - match *k { - // complex key is not supported - Yaml::Array(_) | Yaml::Hash(_) => { - return Err(EmitError::BadHashmapKey); - }, - _ => { try!(self.emit_node(k)); } - } - try!(write!(self.writer, ": ")); - try!(self.emit_node(v)); - } - try!(self.writer.write_str("}")); - self.level -= 1; - Ok(()) - }, + Yaml::Array(ref v) => self.emit_array_compact(v), + Yaml::Hash(ref h) => self.emit_hash_compact(h), _ => self.emit_node(node), } } @@ -213,19 +182,36 @@ impl<'a> YamlEmitter<'a> { try!(write!(self.writer, "[]")); } else { for (cnt, x) in v.iter().enumerate() { + self.level += 1; if cnt > 0 { try!(write!(self.writer, "\n")); } try!(self.write_indent()); - self.level += 1; try!(write!(self.writer, "- ")); - try!(self.emit_node(x)); + if self.level >= 1 && x.is_array() { + try!(self.emit_node_compact(x)); + } else { + try!(self.emit_node(x)); + } self.level -= 1; } } Ok(()) } + fn emit_array_compact(&mut self, v: &[Yaml]) -> EmitResult { + try!(write!(self.writer, "[")); + if self.level >= 0 { + try!(write!(self.writer, "")); + } + for (cnt, x) in v.iter().enumerate() { + if cnt > 0 { try!(write!(self.writer, ", ")); } + try!(self.emit_node(x)); + } + try!(write!(self.writer, "]")); + Ok(()) + } + fn emit_hash(&mut self, h: &Hash) -> EmitResult { if h.is_empty() { try!(self.writer.write_str("{}")); @@ -274,6 +260,29 @@ impl<'a> YamlEmitter<'a> { } Ok(()) } + + fn emit_hash_compact(&mut self, h: &Hash) -> EmitResult { + try!(self.writer.write_str("{")); + self.level += 1; + for (cnt, (k, v)) in h.iter().enumerate() { + if cnt > 0 { + try!(write!(self.writer, ", ")); + } + match *k { + // complex key is not supported + Yaml::Array(_) | Yaml::Hash(_) => { + return Err(EmitError::BadHashmapKey); + }, + _ => { try!(self.emit_node(k)); } + } + try!(write!(self.writer, ": ")); + try!(self.emit_node(v)); + } + try!(self.writer.write_str("}")); + self.level -= 1; + Ok(()) + } + } /// Check if the string requires quoting. @@ -315,7 +324,7 @@ fn need_quotes(string: &str) -> bool { } #[cfg(test)] -mod tests { +mod test { use super::*; use YamlLoader; @@ -330,15 +339,8 @@ a1: a2: 4 # i'm comment a3: [1, 2, 3] a4: - - - a1 - - a2 + - [a1, a2] - 2 - - [] - - {} -a5: 'single_quoted' -a6: \"double_quoted\" -a7: 你好 -'key 1': \"ddd\\\tbbb\" "; @@ -349,7 +351,12 @@ a7: 你好 let mut emitter = YamlEmitter::new(&mut writer); emitter.dump(doc).unwrap(); } - let docs_new = YamlLoader::load_from_str(&s).unwrap(); + println!("original:\n{}", s); + println!("emitted:\n{}", writer); + let docs_new = match YamlLoader::load_from_str(&writer) { + Ok(y) => y, + Err(e) => panic!(format!("{}", e)) + }; let doc_new = &docs_new[0]; assert_eq!(doc, doc_new); @@ -383,7 +390,10 @@ products: let mut emitter = YamlEmitter::new(&mut writer); emitter.dump(doc).unwrap(); } - let docs_new = YamlLoader::load_from_str(&s).unwrap(); + let docs_new = match YamlLoader::load_from_str(&writer) { + Ok(y) => y, + Err(e) => panic!(format!("{}", e)) + }; let doc_new = &docs_new[0]; assert_eq!(doc, doc_new); } @@ -470,6 +480,9 @@ bool1: false"#; assert_eq!(expected, writer, "actual:\n\n{}\n", writer); } +//(left: `"---\na:\n b:\n c: hello\n d: {}\ne:\n- f\n- g\n- h: []"`, +//right: `"---\na:\n b:\n c: hello\n d: {}\ne:\n - f\n - g\n - h: []"`) + #[test] fn test_empty_and_nested() { let s = r#"--- @@ -478,9 +491,9 @@ a: c: hello d: {} e: -- f -- g -- h: []"#; + - f + - g + - h: []"#; let docs = YamlLoader::load_from_str(&s).unwrap(); let doc = &docs[0]; diff --git a/parser/src/yaml.rs b/parser/src/yaml.rs index d745dc6..b8ccdbd 100644 --- a/parser/src/yaml.rs +++ b/parser/src/yaml.rs @@ -266,6 +266,13 @@ impl Yaml { } } + pub fn is_array(&self) -> bool { + match *self { + Yaml::Array(_) => true, + _ => false + } + } + pub fn as_f64(&self) -> Option { match *self { Yaml::Real(ref v) => parse_f64(v), From aaf06fbce9926ba189e20e55c6cc51e8230f6e30 Mon Sep 17 00:00:00 2001 From: Hendrik Sollich Date: Sun, 11 Jun 2017 00:19:20 +0200 Subject: [PATCH 3/5] correctly emitting deeply nested arrays --- parser/src/emitter.rs | 86 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 77 insertions(+), 9 deletions(-) diff --git a/parser/src/emitter.rs b/parser/src/emitter.rs index c7bc154..7a5662e 100644 --- a/parser/src/emitter.rs +++ b/parser/src/emitter.rs @@ -142,7 +142,7 @@ impl<'a> YamlEmitter<'a> { fn emit_node(&mut self, node: &Yaml) -> EmitResult { match *node { - Yaml::Array(ref v) => self.emit_array(v), + Yaml::Array(ref v) => self.emit_array(v, !node.is_array()), Yaml::Hash(ref h) => self.emit_hash(h), Yaml::String(ref v) => { if need_quotes(v) { @@ -177,7 +177,7 @@ impl<'a> YamlEmitter<'a> { } } - fn emit_array(&mut self, v: &[Yaml]) -> EmitResult { + fn emit_array(&mut self, v: &[Yaml], indent_first: bool) -> EmitResult { if v.is_empty() { try!(write!(self.writer, "[]")); } else { @@ -186,12 +186,14 @@ impl<'a> YamlEmitter<'a> { if cnt > 0 { try!(write!(self.writer, "\n")); } - try!(self.write_indent()); + if cnt > 0 || indent_first { + try!(self.write_indent()); + } try!(write!(self.writer, "- ")); - if self.level >= 1 && x.is_array() { + if self.level > 2 { try!(self.emit_node_compact(x)); } else { - try!(self.emit_node(x)); + try!(self.emit_node(x)); } self.level -= 1; } @@ -237,7 +239,7 @@ impl<'a> YamlEmitter<'a> { } else { try!(write!(self.writer, ":\n")); } - try!(self.emit_array(v)); + try!(self.emit_array(v, true)); } Yaml::Hash(ref h) => { if h.is_empty() { @@ -480,9 +482,6 @@ bool1: false"#; assert_eq!(expected, writer, "actual:\n\n{}\n", writer); } -//(left: `"---\na:\n b:\n c: hello\n d: {}\ne:\n- f\n- g\n- h: []"`, -//right: `"---\na:\n b:\n c: hello\n d: {}\ne:\n - f\n - g\n - h: []"`) - #[test] fn test_empty_and_nested() { let s = r#"--- @@ -505,4 +504,73 @@ e: assert_eq!(s, writer); } + + #[test] + fn test_nested_arrays() { + let s = r#"--- +a: + - b + - - c + - d + - - e + - f"#; + + let docs = YamlLoader::load_from_str(&s).unwrap(); + let doc = &docs[0]; + let mut writer = String::new(); + { + let mut emitter = YamlEmitter::new(&mut writer); + emitter.dump(doc).unwrap(); + } + println!("original:\n{}", s); + println!("emitted:\n{}", writer); + + assert_eq!(s, writer); + } + + #[test] + fn test_deeply_nested_arrays() { + let s = r#"--- +a: + - b + - - c + - d + - - e + - [f, e]"#; + + let docs = YamlLoader::load_from_str(&s).unwrap(); + let doc = &docs[0]; + let mut writer = String::new(); + { + let mut emitter = YamlEmitter::new(&mut writer); + emitter.dump(doc).unwrap(); + } + println!("original:\n{}", s); + println!("emitted:\n{}", writer); + + assert_eq!(s, writer); + } + + #[test] + fn test_nested_hashes() { + let s = r#"--- +a: + b: + c: + d: + e: f"#; + + let docs = YamlLoader::load_from_str(&s).unwrap(); + let doc = &docs[0]; + let mut writer = String::new(); + { + let mut emitter = YamlEmitter::new(&mut writer); + emitter.dump(doc).unwrap(); + } + println!("original:\n{}", s); + println!("emitted:\n{}", writer); + + assert_eq!(s, writer); + } + } From 28d17fa242e9b2fc9d5fd941cf559f8a2b816bf4 Mon Sep 17 00:00:00 2001 From: Christian Hofer Date: Wed, 14 Jun 2017 10:29:27 +0200 Subject: [PATCH 4/5] Allow clients ownership of events Also: Optimize built-in Yaml deserializer to avoid one scalar value cloning step. --- parser/src/parser.rs | 82 +++++++++++++++++++++++++++----------------- parser/src/yaml.rs | 22 ++++++------ 2 files changed, 62 insertions(+), 42 deletions(-) diff --git a/parser/src/parser.rs b/parser/src/parser.rs index 7d147e7..e2bbbd3 100644 --- a/parser/src/parser.rs +++ b/parser/src/parser.rs @@ -90,6 +90,15 @@ impl MarkedEventReceiver for R { } } +pub trait MarkedOwnedEventReceiver { + fn on_owned_event(&mut self, ev: Event, _mark: Marker); +} + +impl MarkedOwnedEventReceiver for R { + fn on_owned_event(&mut self, ev: Event, _mark: Marker) { + self.on_event(&ev, _mark); + } +} pub type ParseResult = Result<(Event, Marker), ScanError>; @@ -136,38 +145,37 @@ impl> Parser { self.states.push(state); } - fn parse(&mut self, recv: &mut R) - -> Result { + fn parse(&mut self) -> Result<(Event, Marker), ScanError> { if self.state == State::End { - return Ok(Event::StreamEnd); + return Ok((Event::StreamEnd, self.scanner.mark())); } let (ev, mark) = try!(self.state_machine()); // println!("EV {:?}", ev); - recv.on_event(&ev, mark); - Ok(ev) + Ok((ev, mark)) } - pub fn load(&mut self, recv: &mut R, multi: bool) + pub fn load(&mut self, recv: &mut R, multi: bool) -> Result<(), ScanError> { if !self.scanner.stream_started() { - let ev = try!(self.parse(recv)); + let (ev, mark) = try!(self.parse()); assert_eq!(ev, Event::StreamStart); + recv.on_owned_event(ev, mark); } if self.scanner.stream_ended() { // XXX has parsed? - recv.on_event(&Event::StreamEnd, self.scanner.mark()); + recv.on_owned_event(Event::StreamEnd, self.scanner.mark()); return Ok(()); } loop { - let ev = try!(self.parse(recv)); + let (ev, mark) = try!(self.parse()); if ev == Event::StreamEnd { - recv.on_event(&Event::StreamEnd, self.scanner.mark()); + recv.on_owned_event(ev, mark); return Ok(()); } // clear anchors before a new document self.anchors.clear(); - try!(self.load_document(&ev, recv)); + try!(self.load_document(ev, mark, recv)); if !multi { break; } @@ -175,63 +183,75 @@ impl> Parser { Ok(()) } - fn load_document(&mut self, first_ev: &Event, recv: &mut R) + fn load_document(&mut self, first_ev: Event, mark: Marker, recv: &mut R) -> Result<(), ScanError> { - assert_eq!(first_ev, &Event::DocumentStart); + assert_eq!(first_ev, Event::DocumentStart); + recv.on_owned_event(first_ev, mark); - let ev = try!(self.parse(recv)); - try!(self.load_node(&ev, recv)); + let (ev, mark) = try!(self.parse()); + try!(self.load_node(ev, mark, recv)); // DOCUMENT-END is expected. - let ev = try!(self.parse(recv)); + let (ev, mark) = try!(self.parse()); assert_eq!(ev, Event::DocumentEnd); + recv.on_owned_event(ev, mark); Ok(()) } - fn load_node(&mut self, first_ev: &Event, recv: &mut R) + fn load_node(&mut self, first_ev: Event, mark: Marker, recv: &mut R) -> Result<(), ScanError> { - match *first_ev { + match first_ev { Event::Alias(..) | Event::Scalar(..) => { + recv.on_owned_event(first_ev, mark); Ok(()) }, Event::SequenceStart(_) => { - self.load_sequence(first_ev, recv) + recv.on_owned_event(first_ev, mark); + self.load_sequence(recv) }, Event::MappingStart(_) => { - self.load_mapping(first_ev, recv) + recv.on_owned_event(first_ev, mark); + self.load_mapping(recv) }, _ => { println!("UNREACHABLE EVENT: {:?}", first_ev); unreachable!(); } } } - fn load_mapping(&mut self, _first_ev: &Event, recv: &mut R) + fn load_mapping(&mut self, recv: &mut R) -> Result<(), ScanError> { - let mut ev = try!(self.parse(recv)); - while ev != Event::MappingEnd { + let (mut key_ev, mut key_mark) = try!(self.parse()); + while key_ev != Event::MappingEnd { // key - try!(self.load_node(&ev, recv)); + try!(self.load_node(key_ev, key_mark, recv)); // value - ev = try!(self.parse(recv)); - try!(self.load_node(&ev, recv)); + let (ev, mark) = try!(self.parse()); + try!(self.load_node(ev, mark, recv)); // next event - ev = try!(self.parse(recv)); + let (ev, mark) = try!(self.parse()); + key_ev = ev; + key_mark = mark; + } + recv.on_owned_event(key_ev, key_mark); Ok(()) } - fn load_sequence(&mut self, _first_ev: &Event, recv: &mut R) + fn load_sequence(&mut self, recv: &mut R) -> Result<(), ScanError> { - let mut ev = try!(self.parse(recv)); + let (mut ev, mut mark) = try!(self.parse()); while ev != Event::SequenceEnd { - try!(self.load_node(&ev, recv)); + try!(self.load_node(ev, mark, recv)); // next event - ev = try!(self.parse(recv)); + let (next_ev, next_mark) = try!(self.parse()); + ev = next_ev; + mark = next_mark; } + recv.on_owned_event(ev, mark); Ok(()) } diff --git a/parser/src/yaml.rs b/parser/src/yaml.rs index b8ccdbd..b9d64f4 100644 --- a/parser/src/yaml.rs +++ b/parser/src/yaml.rs @@ -75,10 +75,10 @@ pub struct YamlLoader { anchor_map: BTreeMap, } -impl MarkedEventReceiver for YamlLoader { - fn on_event(&mut self, ev: &Event, _: Marker) { +impl MarkedOwnedEventReceiver for YamlLoader { + fn on_owned_event(&mut self, ev: Event, _: Marker) { // println!("EV {:?}", ev); - match *ev { + match ev { Event::DocumentStart => { // do nothing }, @@ -106,10 +106,10 @@ impl MarkedEventReceiver for YamlLoader { let node = self.doc_stack.pop().unwrap(); self.insert_new_node(node); }, - Event::Scalar(ref v, style, aid, ref tag) => { + Event::Scalar(v, style, aid, tag) => { let node = if style != TScalarStyle::Plain { - Yaml::String(v.clone()) - } else if let Some(TokenType::Tag(ref handle, ref suffix)) = *tag { + Yaml::String(v) + } else if let Some(TokenType::Tag(ref handle, ref suffix)) = tag { // XXX tag:yaml.org,2002: if handle == "!!" { match suffix.as_ref() { @@ -127,8 +127,8 @@ impl MarkedEventReceiver for YamlLoader { } }, "float" => { - match parse_f64(v) { - Some(_) => Yaml::Real(v.clone()), + match parse_f64(&v) { + Some(_) => Yaml::Real(v), None => Yaml::BadValue, } }, @@ -138,14 +138,14 @@ impl MarkedEventReceiver for YamlLoader { _ => Yaml::BadValue, } } - _ => Yaml::String(v.clone()), + _ => Yaml::String(v), } } else { - Yaml::String(v.clone()) + Yaml::String(v) } } else { // Datatype is not specified, or unrecognized - Yaml::from_str(v.as_ref()) + Yaml::from_str(&v) }; self.insert_new_node((node, aid)); From 6600c8f4c532d4920bb1154507d52280f2302b1e Mon Sep 17 00:00:00 2001 From: Christian Hofer Date: Mon, 19 Jun 2017 15:41:26 +0200 Subject: [PATCH 5/5] Always pass events by value - The EventReceiver gets ownership of events - Breaks compatilibility with previous interface --- parser/src/parser.rs | 49 +++++++++++++++------------------------ parser/src/yaml.rs | 4 ++-- parser/tests/spec_test.rs | 4 ++-- 3 files changed, 23 insertions(+), 34 deletions(-) diff --git a/parser/src/parser.rs b/parser/src/parser.rs index e2bbbd3..8b511e9 100644 --- a/parser/src/parser.rs +++ b/parser/src/parser.rs @@ -76,31 +76,20 @@ pub struct Parser { pub trait EventReceiver { - fn on_event(&mut self, ev: &Event); + fn on_event(&mut self, ev: Event); } pub trait MarkedEventReceiver { - fn on_event(&mut self, ev: &Event, _mark: Marker); + fn on_event(&mut self, ev: Event, _mark: Marker); } impl MarkedEventReceiver for R { - fn on_event(&mut self, ev: &Event, _mark: Marker) { + fn on_event(&mut self, ev: Event, _mark: Marker) { self.on_event(ev) } } -pub trait MarkedOwnedEventReceiver { - fn on_owned_event(&mut self, ev: Event, _mark: Marker); -} - -impl MarkedOwnedEventReceiver for R { - fn on_owned_event(&mut self, ev: Event, _mark: Marker) { - self.on_event(&ev, _mark); - } -} - - pub type ParseResult = Result<(Event, Marker), ScanError>; impl> Parser { @@ -145,7 +134,7 @@ impl> Parser { self.states.push(state); } - fn parse(&mut self) -> Result<(Event, Marker), ScanError> { + fn parse(&mut self) -> ParseResult { if self.state == State::End { return Ok((Event::StreamEnd, self.scanner.mark())); } @@ -154,23 +143,23 @@ impl> Parser { Ok((ev, mark)) } - pub fn load(&mut self, recv: &mut R, multi: bool) + pub fn load(&mut self, recv: &mut R, multi: bool) -> Result<(), ScanError> { if !self.scanner.stream_started() { let (ev, mark) = try!(self.parse()); assert_eq!(ev, Event::StreamStart); - recv.on_owned_event(ev, mark); + recv.on_event(ev, mark); } if self.scanner.stream_ended() { // XXX has parsed? - recv.on_owned_event(Event::StreamEnd, self.scanner.mark()); + recv.on_event(Event::StreamEnd, self.scanner.mark()); return Ok(()); } loop { let (ev, mark) = try!(self.parse()); if ev == Event::StreamEnd { - recv.on_owned_event(ev, mark); + recv.on_event(ev, mark); return Ok(()); } // clear anchors before a new document @@ -183,10 +172,10 @@ impl> Parser { Ok(()) } - fn load_document(&mut self, first_ev: Event, mark: Marker, recv: &mut R) + fn load_document(&mut self, first_ev: Event, mark: Marker, recv: &mut R) -> Result<(), ScanError> { assert_eq!(first_ev, Event::DocumentStart); - recv.on_owned_event(first_ev, mark); + recv.on_event(first_ev, mark); let (ev, mark) = try!(self.parse()); try!(self.load_node(ev, mark, recv)); @@ -194,24 +183,24 @@ impl> Parser { // DOCUMENT-END is expected. let (ev, mark) = try!(self.parse()); assert_eq!(ev, Event::DocumentEnd); - recv.on_owned_event(ev, mark); + recv.on_event(ev, mark); Ok(()) } - fn load_node(&mut self, first_ev: Event, mark: Marker, recv: &mut R) + fn load_node(&mut self, first_ev: Event, mark: Marker, recv: &mut R) -> Result<(), ScanError> { match first_ev { Event::Alias(..) | Event::Scalar(..) => { - recv.on_owned_event(first_ev, mark); + recv.on_event(first_ev, mark); Ok(()) }, Event::SequenceStart(_) => { - recv.on_owned_event(first_ev, mark); + recv.on_event(first_ev, mark); self.load_sequence(recv) }, Event::MappingStart(_) => { - recv.on_owned_event(first_ev, mark); + recv.on_event(first_ev, mark); self.load_mapping(recv) }, _ => { println!("UNREACHABLE EVENT: {:?}", first_ev); @@ -219,7 +208,7 @@ impl> Parser { } } - fn load_mapping(&mut self, recv: &mut R) + fn load_mapping(&mut self, recv: &mut R) -> Result<(), ScanError> { let (mut key_ev, mut key_mark) = try!(self.parse()); while key_ev != Event::MappingEnd { @@ -236,11 +225,11 @@ impl> Parser { key_mark = mark; } - recv.on_owned_event(key_ev, key_mark); + recv.on_event(key_ev, key_mark); Ok(()) } - fn load_sequence(&mut self, recv: &mut R) + fn load_sequence(&mut self, recv: &mut R) -> Result<(), ScanError> { let (mut ev, mut mark) = try!(self.parse()); while ev != Event::SequenceEnd { @@ -251,7 +240,7 @@ impl> Parser { ev = next_ev; mark = next_mark; } - recv.on_owned_event(ev, mark); + recv.on_event(ev, mark); Ok(()) } diff --git a/parser/src/yaml.rs b/parser/src/yaml.rs index b9d64f4..5d7ef36 100644 --- a/parser/src/yaml.rs +++ b/parser/src/yaml.rs @@ -75,8 +75,8 @@ pub struct YamlLoader { anchor_map: BTreeMap, } -impl MarkedOwnedEventReceiver for YamlLoader { - fn on_owned_event(&mut self, ev: Event, _: Marker) { +impl MarkedEventReceiver for YamlLoader { + fn on_event(&mut self, ev: Event, _: Marker) { // println!("EV {:?}", ev); match ev { Event::DocumentStart => { diff --git a/parser/tests/spec_test.rs b/parser/tests/spec_test.rs index b7316fc..61f059d 100644 --- a/parser/tests/spec_test.rs +++ b/parser/tests/spec_test.rs @@ -25,8 +25,8 @@ struct YamlChecker { } impl EventReceiver for YamlChecker { - fn on_event(&mut self, ev: &Event) { - let tev = match *ev { + fn on_event(&mut self, ev: Event) { + let tev = match ev { Event::DocumentStart => TestEvent::OnDocumentStart, Event::DocumentEnd => TestEvent::OnDocumentEnd, Event::SequenceStart(..) => TestEvent::OnSequenceStart,