Update TOML to 0.3

Author: Guillaume Fraux

src/input/Cargo.toml

@@ -9,7 +9,7 @@ license = "BSD-3-Clause"
 
 [dependencies]
 lumol-core = {path = "../core"}
-toml = "0.2"
+toml = "0.3"
 log = "0.3"
 chemfiles = "0.7"
 

src/input/src/error.rs

@@ -6,7 +6,6 @@ use std::fmt;
 use std::result;
 use std::path::PathBuf;
 
-use toml::Parser;
 use chemfiles;
 
 use lumol::units::ParseError;
@@ -19,7 +18,7 @@ pub type Result<T> = result::Result<T, Error>;
 #[derive(Debug)]
 pub enum Error {
     /// Error in the TOML input file
-    TOML(String),
+    TOML(Box<error::Error>),
     /// IO error, and associated file path
     Io(io::Error, PathBuf),
     /// Error while reading a trajectory file
@@ -63,31 +62,34 @@ impl From<ParseError> for Error {
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
         use std::error::Error as StdError;
-        let message = match *self {
+        match *self {
             Error::Io(ref err, ref path) => {
                 match err.kind() {
                     io::ErrorKind::NotFound => {
-                        format!("can not find '{}'", path.display())
+                        try!(write!(fmt, "can not find '{}'", path.display()))
                     }
                     io::ErrorKind::PermissionDenied => {
-                        format!("permission to access '{}' denied", path.display())
+                        try!(write!(fmt, "permission to access '{}' denied", path.display()))
                     }
                     _ => {
-                        format!("error with '{}': {}", path.display(), self.description())
+                        try!(write!(fmt, "error with '{}': {}", path.display(), self.description()))
                     }
                 }
             }
-            _ => String::from(self.description())
+            Error::Trajectory(ref err) => try!(write!(fmt, "{}", err)),
+            Error::TOML(ref err) => try!(write!(fmt, "{}", err)),
+            Error::Config(ref err) => try!(write!(fmt, "{}", err)),
+            Error::Unit(ref err) => try!(write!(fmt, "{}", err)),
         };
-        try!(write!(fmt, "{}", message));
         Ok(())
     }
 }
 
 impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::TOML(ref err) | Error::Config(ref err) => err,
+            Error::Config(ref err) => err,
+            Error::TOML(ref err) => err.description(),
             Error::Io(ref err, _) => err.description(),
             Error::Trajectory(ref err) => err.description(),
             Error::Unit(ref err) => err.description(),
@@ -103,13 +105,3 @@ impl error::Error for Error {
         }
     }
 }
-
-pub fn toml_error_to_string(parser: &Parser) -> String {
-    let errors = parser.errors.iter().map(|error|{
-        let (line, _) = parser.to_linecol(error.lo);
-        format!("{} at line {}", error.desc, line + 1)
-    }).collect::<Vec<_>>().join("\n    ");
-
-    let plural = if errors.len() == 1 {""} else {"s"};
-    return format!("TOML parsing error{}: {}", plural, errors);
-}

src/input/src/extract.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Table, Value};
+use toml::value::{Table, Value};
 use error::{Error, Result};
 
 
@@ -68,9 +68,10 @@ pub fn slice<'a>(key: &str, config: &'a Table, context: &str) -> Result<&'a [Val
     let array = try!(config.get(key).ok_or(Error::from(
         format!("Missing '{}' key in {}", key, context)
     )));
-    return array.as_slice().ok_or(Error::from(
+    let array = array.as_array().ok_or(Error::from(
         format!("'{}' must be an array in {}", key, context)
-    ))
+    ));
+    return array.map(|arr| arr.as_slice());
 }
 
 /// Extract the string 'type' key in a TOML table

src/input/src/interactions/angles.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Value, Table};
+use toml::value::{Value, Table};
 
 use lumol::sys::System;
 use lumol::energy::{Harmonic, CosineHarmonic, Torsion, NullPotential};
@@ -22,7 +22,7 @@ impl InteractionsInput {
             None => return Ok(())
         };
 
-        let angles = try!(angles.as_slice().ok_or(
+        let angles = try!(angles.as_array().ok_or(
             Error::from("The 'angles' section must be an array")
         ));
 
@@ -58,7 +58,7 @@ impl InteractionsInput {
             None => return Ok(())
         };
 
-        let dihedrals = try!(dihedrals.as_slice().ok_or(
+        let dihedrals = try!(dihedrals.as_array().ok_or(
             Error::from("The 'dihedrals' section must be an array")
         ));
 

src/input/src/interactions/mod.rs

@@ -1,6 +1,7 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Parser, Table, Value};
+use toml::de::from_str as parse;
+use toml::value::{Table, Value};
 
 use std::io::prelude::*;
 use std::fs::File;
@@ -11,7 +12,6 @@ use lumol::energy::PairRestriction;
 
 use {Error, Result};
 use validate;
-use error::toml_error_to_string;
 
 mod toml;
 mod pairs;
@@ -38,13 +38,11 @@ impl InteractionsInput {
     // TODO: use restricted privacy here
     #[doc(hidden)]
     pub fn from_string(string: &str) -> Result<InteractionsInput> {
-        let mut parser = Parser::new(string);
-        let config = try!(parser.parse().ok_or(
-            Error::TOML(toml_error_to_string(&parser))
-        ));
-
+        let config = try!(parse(string).map_err(|err| {
+            Error::TOML(Box::new(err))
+        }));
         try!(validate(&config));
-        return InteractionsInput::from_toml(config);
+        return InteractionsInput::from_toml(config.clone());
     }
 
     /// Read the interactions from a TOML table. This is an internal function,

src/input/src/interactions/pairs.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Value, Table};
+use toml::value::{Value, Table};
 
 use lumol::sys::System;
 use lumol::units;
@@ -62,7 +62,7 @@ impl InteractionsInput {
             None => return Ok(())
         };
 
-        let pairs = try!(pairs.as_slice().ok_or(
+        let pairs = try!(pairs.as_array().ok_or(
             Error::from("The 'pairs' section must be an array")
         ));
 
@@ -157,7 +157,7 @@ impl InteractionsInput {
             None => return Ok(())
         };
 
-        let bonds = try!(bonds.as_slice().ok_or(
+        let bonds = try!(bonds.as_array().ok_or(
             Error::from("The 'bonds' section must be an array")
         ));
 

src/input/src/interactions/toml.rs

@@ -2,7 +2,7 @@
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
 
 //! Convert TOML values to Lumol types.
-use toml::Table;
+use toml::value::Table;
 
 use error::{Error, Result};
 use FromToml;

src/input/src/lib.rs

@@ -67,7 +67,7 @@ extern crate toml;
 extern crate chemfiles;
 extern crate lumol;
 
-use toml::Table;
+use toml::value::Table;
 
 macro_rules! try_io {
     ($expr: expr, $path: expr) => (
@@ -108,7 +108,7 @@ fn validate(config: &Table) -> Result<()> {
         Error::from("Missing 'input' table")
     ));
 
-    let version = try!(input.lookup("version").ok_or(
+    let version = try!(input.get("version").ok_or(
         Error::from("Missing 'version' key in 'input' table")
     ));
 

src/input/src/simulations/mc.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::Table;
+use toml::value::Table;
 use std::path::PathBuf;
 
 use lumol::sys::{read_molecule, molecule_type};

src/input/src/simulations/md.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::Table;
+use toml::value::Table;
 
 use lumol::sim::md::*;
 use lumol::units;
@@ -68,7 +68,7 @@ impl FromToml for MolecularDynamics {
         }
 
         if let Some(controls) = config.get("controls") {
-            let controls = try!(controls.as_slice().ok_or(Error::from(
+            let controls = try!(controls.as_array().ok_or(Error::from(
                 "'controls' must be an array of tables in molecular dynamics"
             )));
 

src/input/src/simulations/min.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::Table;
+use toml::value::Table;
 
 use lumol::sim::min::*;
 use lumol::units;

src/input/src/simulations/mod.rs

@@ -1,14 +1,14 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Parser, Table};
+use toml::de::from_str as parse;
+use toml::value::Table;
 
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 use std::fs::File;
 
 use validate;
 use error::{Error, Result};
-use error::toml_error_to_string;
 
 use lumol::sim::Simulation;
 use lumol::sys::System;
@@ -54,14 +54,12 @@ impl Input {
     /// Read the `Input` from a TOML formatted string.
     // TODO: use restricted privacy here
     #[doc(hidden)]
-    pub fn from_str(path: PathBuf, buffer: &str) -> Result<Input> {
-        let mut parser = Parser::new(buffer);
-        let config = try!(parser.parse().ok_or(
-            Error::TOML(toml_error_to_string(&parser))
-        ));
-
+    pub fn from_str(path: PathBuf, string: &str) -> Result<Input> {
+        let config = try!(parse(string).map_err(|err| {
+            Error::TOML(Box::new(err))
+        }));
         try!(validate(&config));
-        Ok(Input{path: path, config: config})
+        Ok(Input{path: path, config: config.clone()})
     }
 
     /// Read input file and get the corresponding `Config`

src/input/src/simulations/outputs.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::Table;
+use toml::value::Table;
 use std::path::PathBuf;
 
 use lumol::out::Output;
@@ -19,7 +19,7 @@ impl Input {
     pub fn read_outputs(&self) -> Result<Vec<(Box<Output>, u64)>> {
         let config = try!(self.simulation_table());
         if let Some(outputs) = config.get("outputs") {
-            let outputs = try!(outputs.as_slice().ok_or(
+            let outputs = try!(outputs.as_array().ok_or(
                 Error::from("'outputs' must be an array of tables in simulation")
             ));
 

src/input/src/simulations/simulations.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::Table;
+use toml::value::Table;
 use lumol::sim::Simulation;
 
 use error::{Error, Result};

src/input/src/simulations/system.rs

@@ -1,6 +1,6 @@
 // Lumol, an extensible molecular simulation engine
 // Copyright (C) 2015-2016 Lumol's contributors — BSD license
-use toml::{Table, Value};
+use toml::value::{Table, Value};
 
 use lumol::units;
 use lumol::sys::*;