From f66d8bcf33530c858a502bfa170f2383a8cbc204 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sun, 29 Jan 2017 16:53:20 -0800 Subject: Rewrite crate with serde support from ground up This commit completely rewrites this crate from the ground up, supporting serde at the lowest levels as I believe serde support was intended to do. This is a major change from the previous versions of this crate, with a summary of changes being: * Serialization directly to TOML is now supported without going through a `Value` first. * Deserialization directly from TOML is now supported without going through a `Value`. Note that due to the TOML format some values still are buffered in intermediate memory, but overall this should be at a minimum now. * The API of `Value` was overhauled to match the API of `serde_json::Value`. The changes here were to: * Add `is_*` accessors * Add `get` and `get_mut` for one-field lookups. * Implement panicking lookups through `Index` The old `index` methods are now gone in favor of `get` and `Index` implementations. * A `Datetime` type has been added to represent a TOML datetime in a first-class fashion. Currently this type provides no accessors other than a `Display` implementation, but the idea is that this will grow support over time for decomposing the date. * Support for the `rustc-serialize` crate has been dropped, that'll stay on the 0.2 and 0.1 release trains. * This crate no longer supports the detection of unused fields, for that though you can use the `serde_ignored` crate on crates.io --- examples/decode.rs | 18 +++++++----------- examples/toml2json.rs | 52 +++++++++++++++++++++++---------------------------- 2 files changed, 30 insertions(+), 40 deletions(-) (limited to 'examples') diff --git a/examples/decode.rs b/examples/decode.rs index 9124596..8390e15 100644 --- a/examples/decode.rs +++ b/examples/decode.rs @@ -1,4 +1,4 @@ -//! An example showing off the usage of `RustcDecodable` to automatically decode +//! An example showing off the usage of `Deserialize` to automatically decode //! TOML into a Rust `struct` //! //! Note that this works similarly with `serde` as well. @@ -6,11 +6,12 @@ #![deny(warnings)] extern crate toml; -extern crate rustc_serialize; +#[macro_use] +extern crate serde_derive; /// This is what we're going to decode into. Each field is optional, meaning /// that it doesn't have to be present in TOML. -#[derive(Debug, RustcDecodable)] +#[derive(Debug, Deserialize)] struct Config { global_string: Option, global_integer: Option, @@ -22,13 +23,13 @@ struct Config { /// table. /// /// Again, each field is optional, meaning they don't have to be present. -#[derive(Debug, RustcDecodable)] +#[derive(Debug, Deserialize)] struct ServerConfig { ip: Option, port: Option, } -#[derive(Debug, RustcDecodable)] +#[derive(Debug, Deserialize)] struct PeerConfig { ip: Option, port: Option, @@ -51,11 +52,6 @@ fn main() { ip = "127.0.0.1" "#; - // Use the `decode_str` convenience here to decode a TOML string directly - // into the `Config` struct. - // - // Note that the errors reported here won't necessarily be the best, but you - // can get higher fidelity errors working with `toml::Parser` directly. - let decoded: Config = toml::decode_str(toml_str).unwrap(); + let decoded: Config = toml::from_str(toml_str).unwrap(); println!("{:#?}", decoded); } diff --git a/examples/toml2json.rs b/examples/toml2json.rs index 0d40680..1ed441a 100644 --- a/examples/toml2json.rs +++ b/examples/toml2json.rs @@ -1,57 +1,51 @@ #![deny(warnings)] extern crate toml; -extern crate rustc_serialize; +extern crate serde_json; use std::fs::File; use std::env; use std::io; use std::io::prelude::*; -use toml::Value; -use rustc_serialize::json::Json; +use toml::Value as Toml; +use serde_json::Value as Json; fn main() { let mut args = env::args(); let mut input = String::new(); - let filename = if args.len() > 1 { + if args.len() > 1 { let name = args.nth(1).unwrap(); File::open(&name).and_then(|mut f| { f.read_to_string(&mut input) }).unwrap(); - name } else { io::stdin().read_to_string(&mut input).unwrap(); - "".to_string() - }; + } - let mut parser = toml::Parser::new(&input); - let toml = match parser.parse() { - Some(toml) => toml, - None => { - for err in &parser.errors { - let (loline, locol) = parser.to_linecol(err.lo); - let (hiline, hicol) = parser.to_linecol(err.hi); - println!("{}:{}:{}-{}:{} error: {}", - filename, loline, locol, hiline, hicol, err.desc); - } - return + match input.parse() { + Ok(toml) => { + let json = convert(toml); + println!("{}", serde_json::to_string_pretty(&json).unwrap()); } - }; - let json = convert(Value::Table(toml)); - println!("{}", json.pretty()); + Err(error) => println!("failed to parse TOML: {}", error), + } } -fn convert(toml: Value) -> Json { +fn convert(toml: Toml) -> Json { match toml { - Value::String(s) => Json::String(s), - Value::Integer(i) => Json::I64(i), - Value::Float(f) => Json::F64(f), - Value::Boolean(b) => Json::Boolean(b), - Value::Array(arr) => Json::Array(arr.into_iter().map(convert).collect()), - Value::Table(table) => Json::Object(table.into_iter().map(|(k, v)| { + Toml::String(s) => Json::String(s), + Toml::Integer(i) => Json::Number(i.into()), + Toml::Float(f) => { + let n = serde_json::Number::from_f64(f) + .expect("float infinite and nan not allowed"); + Json::Number(n) + } + Toml::Boolean(b) => Json::Bool(b), + Toml::Array(arr) => Json::Array(arr.into_iter().map(convert).collect()), + Toml::Table(table) => Json::Object(table.into_iter().map(|(k, v)| { (k, convert(v)) }).collect()), - Value::Datetime(dt) => Json::String(dt), + Toml::Datetime(dt) => Json::String(dt.to_string()), } } -- cgit v1.2.3