Update to master
- features - macro reform - String/Show split in formatter - staging
This commit is contained in:
parent
6195861f53
commit
1dfb94afba
|
@ -15,7 +15,7 @@
|
|||
//! "#;
|
||||
//!
|
||||
//! let value = toml::Parser::new(toml).parse().unwrap();
|
||||
//! println!("{}", value);
|
||||
//! println!("{:?}", value);
|
||||
//! ```
|
||||
//!
|
||||
//! # Conversions
|
||||
|
@ -36,9 +36,9 @@
|
|||
//! [2]: https://github.com/BurntSushi/toml-test
|
||||
//!
|
||||
|
||||
#![feature(macro_rules)]
|
||||
#![feature(associated_types)]
|
||||
#![deny(missing_docs)]
|
||||
#![allow(staged_experimental)]
|
||||
#![allow(staged_unstable)]
|
||||
#![cfg_attr(test, deny(warnings))]
|
||||
|
||||
extern crate "rustc-serialize" as rustc_serialize;
|
||||
|
@ -63,7 +63,7 @@ mod show;
|
|||
mod serialization;
|
||||
#[cfg(test)]mod test;
|
||||
/// Representation of a TOML value.
|
||||
#[derive(PartialEq, Clone)]
|
||||
#[derive(PartialEq, Clone, Show)]
|
||||
#[allow(missing_docs)]
|
||||
pub enum Value {
|
||||
String(string::String),
|
||||
|
@ -159,6 +159,7 @@ impl Value {
|
|||
/// Note: arrays have zero-based indexes.
|
||||
///
|
||||
/// ```
|
||||
/// # #![allow(staged_unstable)]
|
||||
/// let toml = r#"
|
||||
/// [test]
|
||||
/// foo = "bar"
|
||||
|
|
|
@ -52,9 +52,9 @@ impl<'a> Parser<'a> {
|
|||
///
|
||||
/// let mut parser = toml::Parser::new(toml);
|
||||
/// match parser.parse() {
|
||||
/// Some(value) => println!("found toml: {}", value),
|
||||
/// Some(value) => println!("found toml: {:?}", value),
|
||||
/// None => {
|
||||
/// println!("parse errors: {}", parser.errors);
|
||||
/// println!("parse errors: {:?}", parser.errors);
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
|
@ -651,7 +651,7 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
Array(ref mut array) => {
|
||||
match array.as_mut_slice().last_mut() {
|
||||
Some(&Table(ref mut table)) => cur = table,
|
||||
Some(&mut Table(ref mut table)) => cur = table,
|
||||
_ => {
|
||||
self.errors.push(ParserError {
|
||||
lo: key_lo,
|
||||
|
@ -699,7 +699,7 @@ impl<'a> Parser<'a> {
|
|||
added = true;
|
||||
}
|
||||
match into.get_mut(&key) {
|
||||
Some(&Table(ref mut table)) => {
|
||||
Some(&mut Table(ref mut table)) => {
|
||||
let any_tables = table.values().any(|v| v.as_table().is_some());
|
||||
if !any_tables && !added {
|
||||
self.errors.push(ParserError {
|
||||
|
|
|
@ -24,6 +24,8 @@ use self::DecodeErrorKind::{ExpectedMapElement, NoEnumVariants, NilTooLong};
|
|||
///
|
||||
/// ```
|
||||
/// # #![feature(old_orphan_check)]
|
||||
/// # #![allow(staged_unstable)]
|
||||
/// # #![allow(staged_experimental)]
|
||||
/// extern crate "rustc-serialize" as rustc_serialize;
|
||||
/// extern crate toml;
|
||||
///
|
||||
|
@ -108,7 +110,7 @@ pub enum DecodeErrorKind {
|
|||
NilTooLong
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Show)]
|
||||
#[derive(PartialEq)]
|
||||
enum EncoderState {
|
||||
Start,
|
||||
NextKey(String),
|
||||
|
@ -793,7 +795,7 @@ impl StdError for DecodeError {
|
|||
NilTooLong => "nonzero length string representing nil",
|
||||
}
|
||||
}
|
||||
fn detail(&self) -> Option<String> { Some(self.to_string()) }
|
||||
fn detail(&self) -> Option<String> { Some(format!("{:?}", self)) }
|
||||
}
|
||||
|
||||
impl fmt::Show for Error {
|
||||
|
@ -811,7 +813,7 @@ impl fmt::Show for Error {
|
|||
|
||||
impl StdError for Error {
|
||||
fn description(&self) -> &str { "TOML encoding error" }
|
||||
fn detail(&self) -> Option<String> { Some(self.to_string()) }
|
||||
fn detail(&self) -> Option<String> { Some(format!("{:?}", self)) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
@ -834,7 +836,7 @@ mod tests {
|
|||
Decodable::decode(&mut d).unwrap()
|
||||
}) );
|
||||
|
||||
macro_rules! map( ($($k:ident: $v:expr),*) => ({
|
||||
macro_rules! map( ($($k:ident, $v:expr),*) => ({
|
||||
let mut _m = BTreeMap::new();
|
||||
$(_m.insert(stringify!($k).to_string(), $v);)*
|
||||
_m
|
||||
|
@ -846,7 +848,7 @@ mod tests {
|
|||
struct Foo { a: int }
|
||||
|
||||
let v = Foo { a: 2 };
|
||||
assert_eq!(encode!(v), map! { a: Integer(2) });
|
||||
assert_eq!(encode!(v), map! { a, Integer(2) });
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
}
|
||||
|
||||
|
@ -856,7 +858,7 @@ mod tests {
|
|||
struct Foo { a_b: int }
|
||||
|
||||
let v = Foo { a_b: 2 };
|
||||
assert_eq!(encode!(v), map! { a_b: Integer(2) });
|
||||
assert_eq!(encode!(v), map! { a_b, Integer(2) });
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
||||
let mut m = BTreeMap::new();
|
||||
|
@ -874,9 +876,9 @@ mod tests {
|
|||
let v = Foo { a: 2, b: Bar { a: "test".to_string() } };
|
||||
assert_eq!(encode!(v),
|
||||
map! {
|
||||
a: Integer(2),
|
||||
b: Table(map! {
|
||||
a: Value::String("test".to_string())
|
||||
a, Integer(2),
|
||||
b, Table(map! {
|
||||
a, Value::String("test".to_string())
|
||||
})
|
||||
});
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
@ -916,7 +918,7 @@ mod tests {
|
|||
let v = Foo { a: vec![1, 2, 3, 4] };
|
||||
assert_eq!(encode!(v),
|
||||
map! {
|
||||
a: Array(vec![
|
||||
a, Array(vec![
|
||||
Integer(1),
|
||||
Integer(2),
|
||||
Integer(3),
|
||||
|
@ -934,7 +936,7 @@ mod tests {
|
|||
let v = Foo { a: (1, 2, 3, 4) };
|
||||
assert_eq!(encode!(v),
|
||||
map! {
|
||||
a: Array(vec![
|
||||
a, Array(vec![
|
||||
Integer(1),
|
||||
Integer(2),
|
||||
Integer(3),
|
||||
|
@ -958,23 +960,23 @@ mod tests {
|
|||
}
|
||||
|
||||
let v = Foo {
|
||||
a: Some(box Foo {
|
||||
a: Some(Box::new(Foo {
|
||||
a: None,
|
||||
b: Bar { a: "foo".to_string(), b: 4.5 },
|
||||
}),
|
||||
})),
|
||||
b: Bar { a: "bar".to_string(), b: 1.0 },
|
||||
};
|
||||
assert_eq!(encode!(v),
|
||||
map! {
|
||||
a: Table(map! {
|
||||
b: Table(map! {
|
||||
a: Value::String("foo".to_string()),
|
||||
b: Float(4.5)
|
||||
a, Table(map! {
|
||||
b, Table(map! {
|
||||
a, Value::String("foo".to_string()),
|
||||
b, Float(4.5)
|
||||
})
|
||||
}),
|
||||
b: Table(map! {
|
||||
a: Value::String("bar".to_string()),
|
||||
b: Float(1.0)
|
||||
b, Table(map! {
|
||||
a, Value::String("bar".to_string()),
|
||||
b, Float(1.0)
|
||||
})
|
||||
});
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
@ -1003,11 +1005,11 @@ mod tests {
|
|||
};
|
||||
assert_eq!(encode!(v),
|
||||
map! {
|
||||
map: Table(map! {
|
||||
foo: Integer(10),
|
||||
bar: Integer(4)
|
||||
map, Table(map! {
|
||||
foo, Integer(10),
|
||||
bar, Integer(4)
|
||||
}),
|
||||
set: Array(vec![Value::String("a".to_string())])
|
||||
set, Array(vec![Value::String("a".to_string())])
|
||||
}
|
||||
);
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
@ -1022,9 +1024,9 @@ mod tests {
|
|||
assert_eq!(
|
||||
encode!(v),
|
||||
map! {
|
||||
_field0: Integer(1),
|
||||
_field1: Value::String("foo".to_string()),
|
||||
_field2: Float(4.5)
|
||||
_field0, Integer(1),
|
||||
_field1, Value::String("foo".to_string()),
|
||||
_field2, Float(4.5)
|
||||
}
|
||||
);
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
@ -1041,9 +1043,9 @@ mod tests {
|
|||
assert_eq!(
|
||||
encode!(v),
|
||||
map! {
|
||||
a: Array(vec![
|
||||
Table(map!{ a: Integer(1) }),
|
||||
Table(map!{ a: Integer(2) }),
|
||||
a, Array(vec![
|
||||
Table(map!{ a, Integer(1) }),
|
||||
Table(map!{ a, Integer(2) }),
|
||||
])
|
||||
}
|
||||
);
|
||||
|
@ -1056,13 +1058,13 @@ mod tests {
|
|||
struct Foo { bar: int }
|
||||
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
bar: Float(1.0)
|
||||
bar, Float(1.0)
|
||||
}));
|
||||
let a: Result<Foo, DecodeError> = Decodable::decode(&mut d);
|
||||
match a {
|
||||
Ok(..) => panic!("should not have decoded"),
|
||||
Err(e) => {
|
||||
assert_eq!(e.to_string().as_slice(),
|
||||
assert_eq!(format!("{:?}", e).as_slice(),
|
||||
"expected a value of type `integer`, but \
|
||||
found a value of type `float` for the key `bar`");
|
||||
}
|
||||
|
@ -1080,7 +1082,7 @@ mod tests {
|
|||
match a {
|
||||
Ok(..) => panic!("should not have decoded"),
|
||||
Err(e) => {
|
||||
assert_eq!(e.to_string().as_slice(),
|
||||
assert_eq!(format!("{:?}", e).as_slice(),
|
||||
"expected a value of type `integer` for the key `bar`");
|
||||
}
|
||||
}
|
||||
|
@ -1104,21 +1106,21 @@ mod tests {
|
|||
let v = Foo { a: E::Bar(10) };
|
||||
assert_eq!(
|
||||
encode!(v),
|
||||
map! { a: Integer(10) }
|
||||
map! { a, Integer(10) }
|
||||
);
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
||||
let v = Foo { a: E::Baz(10.2) };
|
||||
assert_eq!(
|
||||
encode!(v),
|
||||
map! { a: Float(10.2) }
|
||||
map! { a, Float(10.2) }
|
||||
);
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
|
||||
let v = Foo { a: E::Last(Foo2 { test: "test".to_string() }) };
|
||||
assert_eq!(
|
||||
encode!(v),
|
||||
map! { a: Table(map! { test: Value::String("test".to_string()) }) }
|
||||
map! { a, Table(map! { test, Value::String("test".to_string()) }) }
|
||||
);
|
||||
assert_eq!(v, decode!(Table(encode!(v))));
|
||||
}
|
||||
|
@ -1130,13 +1132,13 @@ mod tests {
|
|||
|
||||
let v = Foo { a: 2 };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Integer(2),
|
||||
b: Integer(5)
|
||||
a, Integer(2),
|
||||
b, Integer(5)
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
||||
assert_eq!(d.toml, Some(Table(map! {
|
||||
b: Integer(5)
|
||||
b, Integer(5)
|
||||
})));
|
||||
}
|
||||
|
||||
|
@ -1149,16 +1151,16 @@ mod tests {
|
|||
|
||||
let v = Foo { a: Bar { a: 2 } };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Table(map! {
|
||||
a: Integer(2),
|
||||
b: Integer(5)
|
||||
a, Table(map! {
|
||||
a, Integer(2),
|
||||
b, Integer(5)
|
||||
})
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
||||
assert_eq!(d.toml, Some(Table(map! {
|
||||
a: Table(map! {
|
||||
b: Integer(5)
|
||||
a, Table(map! {
|
||||
b, Integer(5)
|
||||
})
|
||||
})));
|
||||
}
|
||||
|
@ -1172,8 +1174,8 @@ mod tests {
|
|||
|
||||
let v = Foo { a: Bar { a: 2 } };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Table(map! {
|
||||
a: Integer(2)
|
||||
a, Table(map! {
|
||||
a, Integer(2)
|
||||
})
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
@ -1186,10 +1188,10 @@ mod tests {
|
|||
#[derive(RustcEncodable, RustcDecodable, PartialEq, Show)]
|
||||
struct Foo { a: BTreeMap<String, String> }
|
||||
|
||||
let v = Foo { a: map! { a: "foo".to_string() } };
|
||||
let v = Foo { a: map! { a, "foo".to_string() } };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Table(map! {
|
||||
a: Value::String("foo".to_string())
|
||||
a, Table(map! {
|
||||
a, Value::String("foo".to_string())
|
||||
})
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
@ -1204,7 +1206,7 @@ mod tests {
|
|||
|
||||
let v = Foo { a: vec!["a".to_string()] };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Array(vec![Value::String("a".to_string())])
|
||||
a, Array(vec![Value::String("a".to_string())])
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
||||
|
@ -1218,7 +1220,7 @@ mod tests {
|
|||
|
||||
let v = Foo { a: Some(vec![]) };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Array(vec![])
|
||||
a, Array(vec![])
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
||||
|
@ -1234,16 +1236,16 @@ mod tests {
|
|||
|
||||
let v = Foo { a: vec![Bar { a: 1 }] };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Array(vec![Table(map! {
|
||||
a: Integer(1),
|
||||
b: Integer(2)
|
||||
a, Array(vec![Table(map! {
|
||||
a, Integer(1),
|
||||
b, Integer(2)
|
||||
})])
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
|
||||
assert_eq!(d.toml, Some(Table(map! {
|
||||
a: Array(vec![Table(map! {
|
||||
b: Integer(2)
|
||||
a, Array(vec![Table(map! {
|
||||
b, Integer(2)
|
||||
})])
|
||||
})));
|
||||
}
|
||||
|
@ -1273,7 +1275,7 @@ mod tests {
|
|||
|
||||
let v = Foo { a: Some(vec![]) };
|
||||
let mut d = Decoder::new(Table(map! {
|
||||
a: Array(vec![])
|
||||
a, Array(vec![])
|
||||
}));
|
||||
assert_eq!(v, Decodable::decode(&mut d).unwrap());
|
||||
}
|
||||
|
|
44
src/show.rs
44
src/show.rs
|
@ -1,6 +1,7 @@
|
|||
use std::fmt;
|
||||
|
||||
use Table as TomlTable;
|
||||
use Array as TomlArray;
|
||||
use Value::{self, String, Integer, Float, Boolean, Datetime, Array, Table};
|
||||
|
||||
struct Printer<'a, 'b:'a> {
|
||||
|
@ -8,7 +9,7 @@ struct Printer<'a, 'b:'a> {
|
|||
stack: Vec<&'a str>,
|
||||
}
|
||||
|
||||
impl fmt::Show for Value {
|
||||
impl fmt::String for Value {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self {
|
||||
String(ref s) => {
|
||||
|
@ -39,7 +40,10 @@ impl fmt::Show for Value {
|
|||
let mut p = Printer { output: f, stack: Vec::new() };
|
||||
p.print(t)
|
||||
}
|
||||
Array(ref a) => write!(f, "{}", a),
|
||||
Array(ref a) => {
|
||||
let mut p = Printer { output: f, stack: Vec::new() };
|
||||
p.print_array(a)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -89,6 +93,20 @@ impl<'a, 'b> Printer<'a, 'b> {
|
|||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_array(&mut self, array: &'a TomlArray) -> fmt::Result {
|
||||
try!(self.output.write_str("["));
|
||||
let mut first = true;
|
||||
for item in array.iter() {
|
||||
if first {
|
||||
first = false;
|
||||
} else {
|
||||
try!(self.output.write_str(", "));
|
||||
}
|
||||
try!((&item as &fmt::String).fmt(self.output));
|
||||
}
|
||||
self.output.write_str("]")
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
@ -98,7 +116,7 @@ mod tests {
|
|||
use Value::{String, Integer, Float, Boolean, Datetime, Array, Table};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
macro_rules! map( ($($k:expr: $v:expr),*) => ({
|
||||
macro_rules! map( ($($k:expr, $v:expr),*) => ({
|
||||
let mut _m = BTreeMap::new();
|
||||
$(_m.insert($k.to_string(), $v);)*
|
||||
_m
|
||||
|
@ -128,12 +146,12 @@ mod tests {
|
|||
fn table() {
|
||||
assert_eq!(Table(map! { }).to_string().as_slice(),
|
||||
"");
|
||||
assert_eq!(Table(map! { "test": Integer(2) }).to_string().as_slice(),
|
||||
assert_eq!(Table(map! { "test", Integer(2) }).to_string().as_slice(),
|
||||
"test = 2\n");
|
||||
assert_eq!(Table(map! {
|
||||
"test": Integer(2),
|
||||
"test2": Table(map! {
|
||||
"test": String("wut".to_string())
|
||||
"test", Integer(2),
|
||||
"test2", Table(map! {
|
||||
"test", String("wut".to_string())
|
||||
})
|
||||
}).to_string().as_slice(),
|
||||
"test = 2\n\
|
||||
|
@ -141,9 +159,9 @@ mod tests {
|
|||
[test2]\n\
|
||||
test = \"wut\"\n");
|
||||
assert_eq!(Table(map! {
|
||||
"test": Integer(2),
|
||||
"test2": Table(map! {
|
||||
"test": String("wut".to_string())
|
||||
"test", Integer(2),
|
||||
"test2", Table(map! {
|
||||
"test", String("wut".to_string())
|
||||
})
|
||||
}).to_string().as_slice(),
|
||||
"test = 2\n\
|
||||
|
@ -151,9 +169,9 @@ mod tests {
|
|||
[test2]\n\
|
||||
test = \"wut\"\n");
|
||||
assert_eq!(Table(map! {
|
||||
"test": Integer(2),
|
||||
"test2": Array(vec![Table(map! {
|
||||
"test": String("wut".to_string())
|
||||
"test", Integer(2),
|
||||
"test2", Array(vec![Table(map! {
|
||||
"test", String("wut".to_string())
|
||||
})])
|
||||
}).to_string().as_slice(),
|
||||
"test = 2\n\
|
||||
|
|
|
@ -46,7 +46,7 @@ fn to_json(toml: Value) -> Json {
|
|||
fn run(toml: &str, json: &str) {
|
||||
let mut p = Parser::new(toml);
|
||||
let table = p.parse();
|
||||
assert!(p.errors.len() == 0, "had_errors: {}",
|
||||
assert!(p.errors.len() == 0, "had_errors: {:?}",
|
||||
p.errors.iter().map(|e| {
|
||||
(e.desc.clone(), toml.slice(e.lo - 5, e.hi + 5))
|
||||
}).collect::<Vec<(String, &str)>>());
|
||||
|
|
Loading…
Reference in a new issue