Merge #302

302: Update dependencies r=RalfJung a=RalfJung



Co-authored-by: Ralf Jung <post@ralfj.de>

Author: bors[bot]

Cargo.lock

@@ -15,10 +15,10 @@ default-run = "xargo"
 error-chain = "0.12"
 fs2 = "0.4.1"
 libc = "0.2.18"
-rustc_version = "0.1.7"
+rustc_version = "0.2.3"
 serde_json = "1.0"
 tempdir = "0.3.5"
-toml = "0.2.1"
+toml = "0.5.6"
 walkdir = "2.3"
 dirs = "3.0"
 

Cargo.toml

@@ -1,10 +1,9 @@
-use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitStatus};
 use std::{env, fmt};
 
-use toml::Value;
+use toml::{Value, map::Map};
 
 use cli::Args;
 use errors::*;
@@ -96,15 +95,17 @@ fn flags(config: Option<&Config>, target: &str, tool: &str) -> Result<Vec<String
         let mut build = false;
         if let Some(array) = config
             .table
-            .lookup(&format!("target.{}.{}", target, tool))
+            .get("target")
+            .and_then(|t| t.get(target))
+            .and_then(|t| t.get(tool))
             .or_else(|| {
                 build = true;
-                config.table.lookup(&format!("build.{}", tool))
+                config.table.get("build").and_then(|t| t.get(tool))
             }) {
             let mut flags = vec![];
 
             let mut error = false;
-            if let Some(array) = array.as_slice() {
+            if let Some(array) = array.as_array() {
                 for value in array {
                     if let Some(flag) = value.as_str() {
                         flags.push(flag.to_owned());
@@ -161,7 +162,7 @@ pub struct Config {
 
 impl Config {
     pub fn target(&self) -> Result<Option<&str>> {
-        if let Some(v) = self.table.lookup("build.target") {
+        if let Some(v) = self.table.get("build").and_then(|t| t.get("target")) {
             Ok(Some(v.as_str()
                 .ok_or_else(|| format!(".cargo/config: build.target must be a string"))?))
         } else {
@@ -210,9 +211,9 @@ impl<'t> Profile<'t> {
 
 impl<'t> fmt::Display for Profile<'t> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut map = BTreeMap::new();
+        let mut map = Map::new();
         map.insert("profile".to_owned(), {
-            let mut map = BTreeMap::new();
+            let mut map = Map::new();
             map.insert("release".to_owned(), self.table.clone());
             Value::Table(map)
         });
@@ -229,7 +230,8 @@ impl Toml {
     /// `profile.release` part of `Cargo.toml`
     pub fn profile(&self) -> Option<Profile> {
         self.table
-            .lookup("profile.release")
+            .get("profile")
+            .and_then(|t| t.get("release"))
             .map(|t| Profile { table: t })
     }
 }

src/cargo.rs

@@ -111,7 +111,7 @@ fn run(cargo_mode: XargoMode) -> Result<Option<ExitStatus>> {
     let args = cli::args();
     let verbose = args.verbose();
 
-    let meta = rustc::version();
+    let meta = rustc::version().map_err(|_| "could not determine rustc version")?;
 
     if let Some(sc) = args.subcommand() {
         if !sc.needs_sysroot() {

src/lib.rs

@@ -7,7 +7,7 @@ use std::{env, fs};
 
 use rustc_version::VersionMeta;
 use tempdir::TempDir;
-use toml::{Table, Value};
+use toml::{value::Table, Value, map::Map};
 
 use CompilationMode;
 use cargo::{Root, Rustflags};
@@ -381,7 +381,7 @@ pub struct Blueprint {
 }
 
 trait AsTableMut {
-    fn as_table_mut<F, R>(&mut self, on_error_path: F) -> Result<&mut Table>
+    fn as_table_mut_or_err<F, R>(&mut self, on_error_path: F) -> Result<&mut Table>
     where
         F: FnOnce() -> R,
         R: ::std::fmt::Display;
@@ -392,7 +392,7 @@ impl AsTableMut for Value {
     /// the contained table. If it's not return `Err` with an error message.
     /// The result of `on_error_path` will be inserted in the error message and
     /// should indicate the TOML path of `self`.
-    fn as_table_mut<F, R>(&mut self, on_error_path: F) -> Result<&mut Table>
+    fn as_table_mut_or_err<F, R>(&mut self, on_error_path: F) -> Result<&mut Table>
     where
         F: FnOnce() -> R,
         R: ::std::fmt::Display,
@@ -422,9 +422,9 @@ impl Blueprint {
             // add crate to patch section (if not specified)
             fn table_entry<'a>(table: &'a mut Table, key: &str) -> Result<&'a mut Table> {
                 table
-                    .entry(key.into())
+                    .entry(key)
                     .or_insert_with(|| Value::Table(Table::new()))
-                    .as_table_mut(|| key)
+                    .as_table_mut_or_err(|| key)
             }
 
             let crates_io = table_entry(patch, "crates-io")?;
@@ -438,7 +438,7 @@ impl Blueprint {
 
     fn from(toml: Option<&xargo::Toml>, target: &str, base_path: &Path, src: &Src) -> Result<Self> {
         fn make_path_absolute<F, R>(
-            crate_spec: &mut toml::Table,
+            crate_spec: &mut Table,
             base_path: &Path,
             on_error_path: F,
         ) -> Result<()>
@@ -476,8 +476,8 @@ impl Blueprint {
         };
 
         for (k1, v) in patch.iter_mut() {
-            for (k2, v) in v.as_table_mut(|| format!("patch.{}", k1))?.iter_mut() {
-                let krate = v.as_table_mut(|| format!("patch.{}.{}", k1, k2))?;
+            for (k2, v) in v.as_table_mut_or_err(|| format!("patch.{}", k1))?.iter_mut() {
+                let krate = v.as_table_mut_or_err(|| format!("patch.{}.{}", k1, k2))?;
 
                 make_path_absolute(krate, base_path, || format!("patch.{}.{}", k1, k2))?;
             }
@@ -530,11 +530,11 @@ impl Blueprint {
             (None, None) => {
                 // If no dependencies were listed, we assume `core` and `compiler_builtins` as the
                 // dependencies
-                let mut t = BTreeMap::new();
-                let mut core = BTreeMap::new();
+                let mut t = Map::new();
+                let mut core = Map::new();
                 core.insert("stage".to_owned(), Value::Integer(0));
                 t.insert("core".to_owned(), Value::Table(core));
-                let mut cb = BTreeMap::new();
+                let mut cb = Map::new();
                 cb.insert(
                     "features".to_owned(),
                     Value::Array(vec![Value::String("mem".to_owned())]),

src/sysroot.rs

@@ -3,7 +3,7 @@ use std::io::{Read, Write};
 use std::path::Path;
 use std::fs;
 
-use toml::{Parser, Value};
+use toml::Value;
 use walkdir::WalkDir;
 
 use errors::*;
@@ -61,9 +61,8 @@ pub fn mkdir(path: &Path) -> Result<()> {
 
 /// Parses `path` as TOML
 pub fn parse(path: &Path) -> Result<Value> {
-    Ok(Value::Table(Parser::new(&read(path)?)
-        .parse()
-        .ok_or_else(|| format!("{} is not valid TOML", path.display()))?))
+    Ok(toml::from_str(&read(path)?)
+        .map_err(|_| format!("{} is not valid TOML", path.display()))?)
 }
 
 pub fn read(path: &Path) -> Result<String> {

src/util.rs

@@ -105,18 +105,20 @@ pub struct Toml {
 impl Toml {
     /// Returns the `dependencies` part of `Xargo.toml`
     pub fn dependencies(&self) -> Option<&Value> {
-        self.table.lookup("dependencies")
+        self.table.get("dependencies")
     }
 
     /// Returns the `target.{}.dependencies` part of `Xargo.toml`
     pub fn target_dependencies(&self, target: &str) -> Option<&Value> {
         self.table
-            .lookup(&format!("target.{}.dependencies", target))
+            .get("target")
+            .and_then(|t| t.get(target))
+            .and_then(|t| t.get("dependencies"))
     }
 
     /// Returns the `patch` part of `Xargo.toml`
     pub fn patch(&self) -> Option<&Value> {
-        self.table.lookup("patch")
+        self.table.get("patch")
     }
 }
 

src/xargo.rs

@@ -79,7 +79,7 @@ fn exists(krate: &str, target: &str) -> Result<bool> {
 }
 
 fn host() -> String {
-    rustc_version::version_meta().host
+    rustc_version::version_meta().unwrap().host
 }
 
 fn mkdir(path: &Path) -> Result<()> {