From 22ad6e7ea9f2a81aac3ba9e427dd8a1036453486 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sun, 21 Sep 2014 07:55:13 -0700 Subject: [PATCH] Update to rust master Closes #19 --- src/lib.rs | 15 ++++++++------- src/parser.rs | 28 ++++++++++++++-------------- src/serialization.rs | 38 +++++++++++++++++++------------------- src/show.rs | 4 ++-- src/test/valid.rs | 4 ++-- 5 files changed, 45 insertions(+), 44 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 10b3e15..c43eab4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -46,6 +46,7 @@ extern crate serialize; use std::collections::TreeMap; use std::from_str::FromStr; +use std::string; pub use parser::{Parser,ParserError}; pub use serialization::{Encoder, encode, encode_str}; @@ -61,17 +62,17 @@ mod serialization; #[deriving(PartialEq, Clone)] #[allow(missing_doc)] pub enum Value { - String(String), + String(string::String), Integer(i64), Float(f64), Boolean(bool), - Datetime(String), - Array(Array), - Table(Table), + Datetime(string::String), + Array(TomlArray), + Table(TomlTable), } -pub type Array = Vec; -pub type Table = TreeMap; +pub type TomlArray = Vec; +pub type TomlTable = TreeMap; impl Value { /// Tests whether this and another value have the same type. @@ -140,7 +141,7 @@ impl Value { } /// Extracts the table value if it is a table. - pub fn as_table<'a>(&'a self) -> Option<&'a Table> { + pub fn as_table<'a>(&'a self) -> Option<&'a TomlTable> { match *self { Table(ref s) => Some(s), _ => None } } diff --git a/src/parser.rs b/src/parser.rs index 6632168..cbf8b6d 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -3,7 +3,7 @@ use std::collections::{TreeMap, HashSet}; use std::num::FromStrRadix; use std::str; -use {Array, Table, Value, String, Float, Integer, Boolean, Datetime}; +use {Array, Table, Value, Float, Integer, Boolean, Datetime, TomlTable}; /// Parser for converting a string to a TOML `Value` instance. /// @@ -129,13 +129,13 @@ impl<'a> Parser<'a> { /// Executes the parser, parsing the string contained within. /// - /// This function will return the `Table` instance if parsing is successful, - /// or it will return `None` if any parse error or invalid TOML error - /// occurs. + /// This function will return the `TomlTable` instance if parsing is + /// successful, or it will return `None` if any parse error or invalid TOML + /// error occurs. /// /// If an error occurs, the `errors` field of this parser can be consulted /// to determine the cause of the parse failure. - pub fn parse(&mut self) -> Option { + pub fn parse(&mut self) -> Option { let mut ret = TreeMap::new(); loop { self.ws(); @@ -189,7 +189,7 @@ impl<'a> Parser<'a> { } } - fn values(&mut self, into: &mut Table) -> bool { + fn values(&mut self, into: &mut TomlTable) -> bool { loop { self.ws(); match self.cur.clone().next() { @@ -273,7 +273,7 @@ impl<'a> Parser<'a> { self.eat('\n'); } else { // empty - return Some(String(ret)) + return Some(::String(ret)) } } @@ -315,7 +315,7 @@ impl<'a> Parser<'a> { } } - return Some(String(ret)); + return Some(::String(ret)); fn escape(me: &mut Parser, pos: uint, multiline: bool) -> Option { match me.cur.next() { @@ -434,7 +434,7 @@ impl<'a> Parser<'a> { } } - return Some(String(ret)); + return Some(::String(ret)); } fn number_or_datetime(&mut self, start: uint) -> Option { @@ -595,7 +595,7 @@ impl<'a> Parser<'a> { return Some(Array(ret)) } - fn insert(&mut self, into: &mut Table, key: String, value: Value, + fn insert(&mut self, into: &mut TomlTable, key: String, value: Value, key_lo: uint) { if into.contains_key(&key) { self.errors.push(ParserError { @@ -608,8 +608,8 @@ impl<'a> Parser<'a> { } } - fn recurse<'a>(&mut self, mut cur: &'a mut Table, orig_key: &'a str, - key_lo: uint) -> Option<(&'a mut Table, &'a str)> { + fn recurse<'a>(&mut self, mut cur: &'a mut TomlTable, orig_key: &'a str, + key_lo: uint) -> Option<(&'a mut TomlTable, &'a str)> { if orig_key.starts_with(".") || orig_key.ends_with(".") || orig_key.contains("..") { self.errors.push(ParserError { @@ -670,7 +670,7 @@ impl<'a> Parser<'a> { return Some((cur, orig_key.slice_from(key.len() + 1))) } - fn insert_table(&mut self, into: &mut Table, key: String, value: Table, + fn insert_table(&mut self, into: &mut TomlTable, key: String, value: TomlTable, key_lo: uint) { if !self.tables_defined.insert(key.clone()) { self.errors.push(ParserError { @@ -712,7 +712,7 @@ impl<'a> Parser<'a> { } } - fn insert_array(&mut self, into: &mut Table, key: String, value: Value, + fn insert_array(&mut self, into: &mut TomlTable, key: String, value: Value, key_lo: uint) { let (into, key) = match self.recurse(into, key.as_slice(), key_lo) { Some(pair) => pair, diff --git a/src/serialization.rs b/src/serialization.rs index 2eb9c24..706e26c 100644 --- a/src/serialization.rs +++ b/src/serialization.rs @@ -3,7 +3,7 @@ use std::mem; use std::fmt; use serialize; -use {Value, Table, Array, String, Integer, Float, Boolean, Parser}; +use {Value, Table, Array, Integer, Float, Boolean, Parser, TomlTable}; /// A structure to transform Rust values into TOML values. /// @@ -38,7 +38,7 @@ pub struct Encoder { /// /// This field can be used to extract the return value after feeding a value /// into this `Encoder`. - pub toml: Table, + pub toml: TomlTable, state: EncoderState, } @@ -142,7 +142,7 @@ impl Encoder { } NextMapKey => { match v { - String(s) => { self.state = NextKey(s); Ok(()) } + ::String(s) => { self.state = NextKey(s); Ok(()) } _ => Err(InvalidMapKeyType) } } @@ -194,7 +194,7 @@ impl serialize::Encoder for Encoder { self.emit_str(v.to_string().as_slice()) } fn emit_str(&mut self, v: &str) -> Result<(), Error> { - self.emit_value(String(v.to_string())) + self.emit_value(::String(v.to_string())) } fn emit_enum(&mut self, _name: &str, f: |&mut Encoder| -> Result<(), Error>) -> Result<(), Error> { @@ -409,8 +409,8 @@ impl Decoder { impl serialize::Decoder for Decoder { fn read_nil(&mut self) -> Result<(), DecodeError> { match self.toml { - Some(String(ref s)) if s.len() == 0 => {} - Some(String(..)) => return Err(self.err(NilTooLong)), + Some(::String(ref s)) if s.len() == 0 => {} + Some(::String(..)) => return Err(self.err(NilTooLong)), ref found => return Err(self.mismatch("string", found)), } self.toml.take(); @@ -466,7 +466,7 @@ impl serialize::Decoder for Decoder { } fn read_char(&mut self) -> Result { let ch = match self.toml { - Some(String(ref s)) if s.as_slice().char_len() == 1 => + Some(::String(ref s)) if s.as_slice().char_len() == 1 => s.as_slice().char_at(0), ref found => return Err(self.mismatch("string", found)), }; @@ -475,7 +475,7 @@ impl serialize::Decoder for Decoder { } fn read_str(&mut self) -> Result { match self.toml.take() { - Some(String(s)) => Ok(s), + Some(::String(s)) => Ok(s), found => { let err = Err(self.mismatch("string", &found)); self.toml = found; @@ -673,7 +673,7 @@ impl serialize::Decoder for Decoder { Some(Table(ref table)) => { match table.iter().skip(idx).next() { Some((key, _)) => { - f(&mut self.sub_decoder(Some(String(key.to_string())), + f(&mut self.sub_decoder(Some(::String(key.to_string())), key.as_slice())) } None => Err(self.err(ExpectedMapKey(idx))), @@ -761,7 +761,7 @@ mod tests { use serialize::{Encodable, Decodable}; use super::{Encoder, Decoder, DecodeError}; - use {Table, Integer, String, Array, Float}; + use {Table, Integer, Array, Float}; macro_rules! encode( ($t:expr) => ({ let mut e = Encoder::new(); @@ -816,7 +816,7 @@ mod tests { map! { a: Integer(2), b: Table(map! { - a: String("test".to_string()) + a: ::String("test".to_string()) }) }); assert_eq!(v, decode!(Table(encode!(v)))); @@ -837,7 +837,7 @@ mod tests { } } let mut d_good = Decoder::new(Integer(5)); - let mut d_bad1 = Decoder::new(String("not an int".to_string())); + let mut d_bad1 = Decoder::new(::String("not an int".to_string())); let mut d_bad2 = Decoder::new(Integer(11)); assert_eq!(Ok(Range10(5)), Decodable::decode(&mut d_good)); @@ -908,12 +908,12 @@ mod tests { map! { a: Table(map! { b: Table(map! { - a: String("foo".to_string()), + a: ::String("foo".to_string()), b: Float(4.5) }) }), b: Table(map! { - a: String("bar".to_string()), + a: ::String("bar".to_string()), b: Float(1.0) }) }); @@ -947,7 +947,7 @@ mod tests { foo: Integer(10), bar: Integer(4) }), - set: Array(vec![String("a".to_string())]) + set: Array(vec![::String("a".to_string())]) } ); assert_eq!(v, decode!(Table(encode!(v)))); @@ -963,7 +963,7 @@ mod tests { encode!(v), map! { _field0: Integer(1), - _field1: String("foo".to_string()), + _field1: ::String("foo".to_string()), _field2: Float(4.5) } ); @@ -1058,7 +1058,7 @@ mod tests { let v = Foo { a: Last(Foo2 { test: "test".to_string() }) }; assert_eq!( encode!(v), - map! { a: Table(map! { test: String("test".to_string()) }) } + map! { a: Table(map! { test: ::String("test".to_string()) }) } ); assert_eq!(v, decode!(Table(encode!(v)))); } @@ -1129,7 +1129,7 @@ mod tests { let v = Foo { a: map! { a: "foo".to_string() } }; let mut d = Decoder::new(Table(map! { a: Table(map! { - a: String("foo".to_string()) + a: ::String("foo".to_string()) }) })); assert_eq!(v, Decodable::decode(&mut d).unwrap()); @@ -1144,7 +1144,7 @@ mod tests { let v = Foo { a: vec!["a".to_string()] }; let mut d = Decoder::new(Table(map! { - a: Array(vec![String("a".to_string())]) + a: Array(vec![::String("a".to_string())]) })); assert_eq!(v, Decodable::decode(&mut d).unwrap()); diff --git a/src/show.rs b/src/show.rs index a8a302e..3499eff 100644 --- a/src/show.rs +++ b/src/show.rs @@ -1,6 +1,6 @@ use std::fmt; -use {Value, String, Integer, Float, Boolean, Datetime, Array, Table}; +use {Value, String, Integer, Float, Boolean, Datetime, Array, Table, TomlTable}; struct Printer<'a, 'b:'a> { output: &'a mut fmt::Formatter<'b>, @@ -51,7 +51,7 @@ impl fmt::Show for Value { } impl<'a, 'b> Printer<'a, 'b> { - fn print(&mut self, table: &'a Table) -> fmt::Result { + fn print(&mut self, table: &'a TomlTable) -> fmt::Result { for (k, v) in table.iter() { match *v { Table(..) => continue, diff --git a/src/test/valid.rs b/src/test/valid.rs index 76ca9fb..05d3172 100644 --- a/src/test/valid.rs +++ b/src/test/valid.rs @@ -4,7 +4,7 @@ use std::num::strconv; use std::collections::TreeMap; use self::serialize::json; -use {Parser, Value, Table, String, Integer, Float, Boolean, Datetime, Array}; +use {Parser, Value, Table, Integer, Float, Boolean, Datetime, Array}; fn to_json(toml: Value) -> json::Json { fn doit(s: &str, json: json::Json) -> json::Json { @@ -14,7 +14,7 @@ fn to_json(toml: Value) -> json::Json { json::Object(map) } match toml { - String(s) => doit("string", json::String(s)), + ::String(s) => doit("string", json::String(s)), Integer(i) => doit("integer", json::String(i.to_string())), Float(f) => doit("float", json::String({ let (bytes, _) =