2 files changed, 30 insertions, 40 deletions

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<String>,
     global_integer: Option<u64>,
@@ -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<String>,
     port: Option<u64>,
 }
 
-#[derive(Debug, RustcDecodable)]
+#[derive(Debug, Deserialize)]
 struct PeerConfig {
     ip: Option<String>,
     port: Option<u64>,
@@ -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();
-        "<stdin>".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()),
     }
 }