From bfcfa89e9566ef179fae47e62a8f8290ff3a3980 Mon Sep 17 00:00:00 2001 From: Victor Berger Date: Tue, 18 Nov 2014 09:13:21 +0100 Subject: [PATCH] Update to namespaced enum variants. --- src/lib.rs | 14 ++++++++----- src/parser.rs | 12 ++++++----- src/serialization.rs | 49 +++++++++++++++++++++++++------------------- src/show.rs | 6 ++++-- src/test/valid.rs | 5 +++-- 5 files changed, 51 insertions(+), 35 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 2e27dea..df6abbc 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -50,11 +50,15 @@ use std::string; pub use parser::{Parser, ParserError}; pub use serialization::{Encoder, encode, encode_str}; pub use serialization::{Decoder, decode, decode_str}; -pub use serialization::{Error, NeedsKey, NoValue}; -pub use serialization::{InvalidMapKeyLocation, InvalidMapKeyType}; -pub use serialization::{DecodeError, ApplicationError, ExpectedField}; -pub use serialization::{ExpectedMapElement, ExpectedMapKey, NoEnumVariants}; -pub use serialization::{ExpectedType, NilTooLong}; +pub use serialization::Error; +pub use serialization::Error::{NeedsKey, NoValue}; +pub use serialization::Error::{InvalidMapKeyLocation, InvalidMapKeyType}; +pub use serialization::{DecodeError, DecodeErrorKind}; +pub use serialization::DecodeErrorKind::{ApplicationError, ExpectedField}; +pub use serialization::DecodeErrorKind::{ExpectedMapElement, ExpectedMapKey, NoEnumVariants}; +pub use serialization::DecodeErrorKind::{ExpectedType, NilTooLong}; + +pub use Value::{String, Integer, Float, Boolean, Datetime, Array, Table}; mod parser; mod show; diff --git a/src/parser.rs b/src/parser.rs index 921b917..69549e7 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -4,7 +4,8 @@ use std::error::Error; use std::num::FromStrRadix; use std::str; -use {Array, Table, Value, Float, Integer, Boolean, Datetime, TomlTable}; +use {Value, TomlTable}; +use Value::{Array, Table, Float, Integer, Boolean, Datetime}; /// Parser for converting a string to a TOML `Value` instance. /// @@ -285,7 +286,7 @@ impl<'a> Parser<'a> { self.eat('\n'); } else { // empty - return Some(::String(ret)) + return Some(Value::String(ret)) } } @@ -328,7 +329,7 @@ impl<'a> Parser<'a> { } } - return Some(::String(ret)); + return Some(Value::String(ret)); fn escape(me: &mut Parser, pos: uint, multiline: bool) -> Option { match me.cur.next() { @@ -447,7 +448,7 @@ impl<'a> Parser<'a> { } } - return Some(::String(ret)); + return Some(Value::String(ret)); } fn number_or_datetime(&mut self, start: uint) -> Option { @@ -768,7 +769,8 @@ impl Error for ParserError { #[cfg(test)] mod tests { - use {Table, Parser}; + use Value::Table; + use Parser; #[test] fn crlf() { diff --git a/src/serialization.rs b/src/serialization.rs index 91f7924..e30de48 100644 --- a/src/serialization.rs +++ b/src/serialization.rs @@ -4,7 +4,13 @@ use std::fmt; use std::error::Error as StdError; use serialize; -use {Value, Table, Array, Integer, Float, Boolean, Parser, TomlTable}; +use {Value, Parser, TomlTable}; +use Value::{Table, Array, Integer, Float, Boolean}; + +use self::EncoderState::{Start, NextKey, NextArray, NextMapKey}; +use self::Error::{NeedsKey, NoValue, InvalidMapKeyLocation, InvalidMapKeyType}; +use self::DecodeErrorKind::{ApplicationError, ExpectedField, ExpectedType, ExpectedMapKey}; +use self::DecodeErrorKind::{ExpectedMapElement, NoEnumVariants, NilTooLong}; /// A structure to transform Rust values into TOML values. /// @@ -142,7 +148,7 @@ impl Encoder { } NextMapKey => { match v { - ::String(s) => { self.state = NextKey(s); Ok(()) } + Value::String(s) => { self.state = NextKey(s); Ok(()) } _ => Err(InvalidMapKeyType) } } @@ -194,7 +200,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(Value::String(v.to_string())) } fn emit_enum(&mut self, _name: &str, f: |&mut Encoder| -> Result<(), Error>) -> Result<(), Error> { @@ -409,8 +415,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(Value::String(ref s)) if s.len() == 0 => {} + Some(Value::String(..)) => return Err(self.err(NilTooLong)), ref found => return Err(self.mismatch("string", found)), } self.toml.take(); @@ -466,7 +472,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(Value::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 +481,7 @@ impl serialize::Decoder for Decoder { } fn read_str(&mut self) -> Result { match self.toml.take() { - Some(::String(s)) => Ok(s), + Some(Value::String(s)) => Ok(s), found => { let err = Err(self.mismatch("string", &found)); self.toml = found; @@ -680,7 +686,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(Value::String(key.to_string())), key.as_slice())) } None => Err(self.err(ExpectedMapKey(idx))), @@ -801,7 +807,8 @@ mod tests { use serialize::{Encodable, Decodable}; use super::{Encoder, Decoder, DecodeError}; - use {Table, Integer, Array, Float}; + use Value; + use Value::{Table, Integer, Array, Float}; macro_rules! encode( ($t:expr) => ({ let mut e = Encoder::new(); @@ -856,7 +863,7 @@ mod tests { map! { a: Integer(2), b: Table(map! { - a: ::String("test".to_string()) + a: Value::String("test".to_string()) }) }); assert_eq!(v, decode!(Table(encode!(v)))); @@ -877,7 +884,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(Value::String("not an int".to_string())); let mut d_bad2 = Decoder::new(Integer(11)); assert_eq!(Ok(Range10(5)), Decodable::decode(&mut d_good)); @@ -948,12 +955,12 @@ mod tests { map! { a: Table(map! { b: Table(map! { - a: ::String("foo".to_string()), + a: Value::String("foo".to_string()), b: Float(4.5) }) }), b: Table(map! { - a: ::String("bar".to_string()), + a: Value::String("bar".to_string()), b: Float(1.0) }) }); @@ -987,7 +994,7 @@ mod tests { foo: Integer(10), bar: Integer(4) }), - set: Array(vec![::String("a".to_string())]) + set: Array(vec![Value::String("a".to_string())]) } ); assert_eq!(v, decode!(Table(encode!(v)))); @@ -1003,7 +1010,7 @@ mod tests { encode!(v), map! { _field0: Integer(1), - _field1: ::String("foo".to_string()), + _field1: Value::String("foo".to_string()), _field2: Float(4.5) } ); @@ -1081,24 +1088,24 @@ mod tests { test: String, } - let v = Foo { a: Bar(10) }; + let v = Foo { a: E::Bar(10) }; assert_eq!( encode!(v), map! { a: Integer(10) } ); assert_eq!(v, decode!(Table(encode!(v)))); - let v = Foo { a: Baz(10.2) }; + let v = Foo { a: E::Baz(10.2) }; assert_eq!( encode!(v), map! { a: Float(10.2) } ); assert_eq!(v, decode!(Table(encode!(v)))); - let v = Foo { a: Last(Foo2 { test: "test".to_string() }) }; + let v = Foo { a: E::Last(Foo2 { test: "test".to_string() }) }; assert_eq!( encode!(v), - map! { a: Table(map! { test: ::String("test".to_string()) }) } + map! { a: Table(map! { test: Value::String("test".to_string()) }) } ); assert_eq!(v, decode!(Table(encode!(v)))); } @@ -1169,7 +1176,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: Value::String("foo".to_string()) }) })); assert_eq!(v, Decodable::decode(&mut d).unwrap()); @@ -1184,7 +1191,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![Value::String("a".to_string())]) })); assert_eq!(v, Decodable::decode(&mut d).unwrap()); diff --git a/src/show.rs b/src/show.rs index 27733ed..d754c7c 100644 --- a/src/show.rs +++ b/src/show.rs @@ -1,6 +1,7 @@ use std::fmt; -use {Value, String, Integer, Float, Boolean, Datetime, Array, Table, TomlTable}; +use {Value, TomlTable}; +use Value::{String, Integer, Float, Boolean, Datetime, Array, Table}; struct Printer<'a, 'b:'a> { output: &'a mut fmt::Formatter<'b>, @@ -100,7 +101,8 @@ impl<'a, 'b> Printer<'a, 'b> { #[cfg(test)] #[allow(warnings)] mod tests { - use {Value, String, Integer, Float, Boolean, Datetime, Array, Table}; + use Value; + use Value::{String, Integer, Float, Boolean, Datetime, Array, Table}; use std::collections::TreeMap; macro_rules! map( ($($k:expr: $v:expr),*) => ({ diff --git a/src/test/valid.rs b/src/test/valid.rs index 05d3172..b60277e 100644 --- a/src/test/valid.rs +++ b/src/test/valid.rs @@ -4,7 +4,8 @@ use std::num::strconv; use std::collections::TreeMap; use self::serialize::json; -use {Parser, Value, Table, Integer, Float, Boolean, Datetime, Array}; +use {Parser, Value}; +use 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 +15,7 @@ fn to_json(toml: Value) -> json::Json { json::Object(map) } match toml { - ::String(s) => doit("string", json::String(s)), + Value::String(s) => doit("string", json::String(s)), Integer(i) => doit("integer", json::String(i.to_string())), Float(f) => doit("float", json::String({ let (bytes, _) =