From f66d8bcf33530c858a502bfa170f2383a8cbc204 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
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/toml2json.rs | 52 +++++++++++++++++++++++----------------------------
 1 file changed, 23 insertions(+), 29 deletions(-)

(limited to 'examples/toml2json.rs')

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()),
     }
 }
-- 
cgit v1.2.3