Update all tracking toolchains on multirust update

Fixes #8

Author: Diggsey

Cargo.toml

@@ -22,6 +22,7 @@ regex = "0.1.41"
 rand = "0.3.11"
 hyper = "0.6.14"
 term = "0.2.11"
+itertools = "0.4.1"
 
 [target.x86_64-pc-windows-gnu.dependencies]
 winapi = "0.2.4"

rust-install/src/dist.rs

@@ -103,6 +103,10 @@ impl ToolchainDesc {
 			format!("{}-{} (tracking)", triple, &self.channel)
 		}
 	}
+	
+	pub fn is_tracking(&self) -> bool {
+		self.date.is_none()
+	}
 }
 
 pub struct Manifest<'a>(temp::File<'a>, String);

rust-install/src/errors.rs

@@ -34,6 +34,7 @@ pub enum Notification<'a> {
 	UpdateHashMatches(&'a str),
 	CantReadUpdateHash(&'a Path),
 	NoUpdateHash(&'a Path),
+	NonFatalError(&'a Error),
 }
 
 pub enum Error {
@@ -110,6 +111,8 @@ impl<'a> Notification<'a> {
 				NotificationLevel::Info,
 			NoCanonicalPath(_) | CantReadUpdateHash(_) =>
 				NotificationLevel::Warn,
+			NonFatalError(_) =>
+				NotificationLevel::Error,
 		}
 	}
 }
@@ -163,6 +166,8 @@ impl<'a> Display for Notification<'a> {
 				write!(f, "can't read update hash file: '{}', can't skip update...", path.display()),
 			NoUpdateHash(path) =>
 				write!(f, "no update hash at: '{}'", path.display()),
+			NonFatalError(e) =>
+				write!(f, "{}", e),
 		}
 	}
 }

rust-install/src/notify.rs

@@ -30,4 +30,5 @@ pub enum NotificationLevel {
 	Normal,
 	Info,
 	Warn,
+	Error,
 }

src/cli.rs

@@ -54,7 +54,7 @@ To remove an existing override use `multirust remove-override`."
 				.after_help(
 r"With no toolchain specified, the update command updates each of the
 stable, beta, and nightly toolchains from the official release
-channels."
+channels, plus any other installed toolchains."
             	)
 				.arg(Arg::with_name("toolchain").required(false))
 				.args(install_args())

src/config.rs

@@ -6,6 +6,8 @@ use std::fs;
 use std::process::Command;
 use std::fmt::{self, Display};
 
+use itertools::Itertools;
+
 use rust_install::*;
 use override_db::OverrideDB;
 use toolchain::Toolchain;
@@ -239,12 +241,19 @@ impl Cfg {
 		}
 	}
 
-	pub fn update_all_channels(&self) -> [Result<()>; 3] {
-		let stable_result = self.get_toolchain("stable", true).and_then(|t| t.install_from_dist());
-		let beta_result = self.get_toolchain("beta", true).and_then(|t| t.install_from_dist());
-		let nightly_result = self.get_toolchain("nightly", true).and_then(|t| t.install_from_dist());
+	pub fn update_all_channels(&self) -> Result<Vec<(String, Result<()>)>> {
+		let mut toolchains = try!(self.list_toolchains());
+		toolchains.sort();
 
-		[stable_result, beta_result, nightly_result]
+		Ok(toolchains.into_iter()
+			.merge(["beta", "nightly", "stable"].into_iter().map(|s| (*s).to_owned()))
+			.dedup()
+			.filter(|name| dist::ToolchainDesc::from_str(&name).map(|d| d.is_tracking()) == Some(true))
+			.map(|name| {
+				let result = self.get_toolchain(&name, true).and_then(|t| t.install_from_dist());
+				(name, result)
+			})
+			.collect())
 	}
 
 	pub fn check_metadata_version(&self) -> Result<bool> {

src/lib.rs

@@ -3,6 +3,7 @@ extern crate rust_install;
 extern crate rand;
 extern crate hyper;
 extern crate regex;
+extern crate itertools;
 
 pub use rust_install::*;
 pub use config::*;

src/main.rs

@@ -22,6 +22,7 @@ use std::process::{Command, Stdio};
 use std::process;
 use std::ffi::OsStr;
 use std::fmt;
+use std::iter;
 use multirust::*;
 
 mod cli;
@@ -79,7 +80,10 @@ fn set_globals(m: Option<&ArgMatches>) -> Result<Cfg> {
 			},
 			NotificationLevel::Warn => {
 				warn!("{}", n);
-			}
+			},
+			NotificationLevel::Error => {
+				err!("{}", n);
+			},
 		}
 	}))
 
@@ -497,18 +501,22 @@ fn show_tool_versions(toolchain: &Toolchain) -> Result<()> {
 
 		try!(toolchain.prefix().with_ldpath(|| {
 			if utils::is_file(&rustc_path) {
-				Command::new(&rustc_path)
-					.arg("--version")
-					.status()
-					.ok().expect("failed to run rustc");
+				let mut cmd = Command::new(&rustc_path);
+				cmd.arg("--version");
+				
+				if utils::cmd_status("rustc", cmd).is_err() {
+					println!("(failed to run rustc)");
+				}
 			} else {
 				println!("(no rustc command in toolchain?)");
 			}
 			if utils::is_file(&cargo_path) {
-				Command::new(&cargo_path)
-					.arg("--version")
-					.status()
-					.ok().expect("failed to run cargo");
+				let mut cmd = Command::new(&cargo_path);
+				cmd.arg("--version");
+				
+				if utils::cmd_status("cargo", cmd).is_err() {
+					println!("(failed to run cargo)");
+				}
 			} else {
 				println!("(no cargo command in toolchain?)");
 			}
@@ -577,30 +585,37 @@ fn list_toolchains(cfg: &Cfg) -> Result<()> {
 }
 
 fn update_all_channels(cfg: &Cfg) -> Result<()> {
-	let result = cfg.update_all_channels();
+	let toolchains = try!(cfg.update_all_channels());
 
-	if result[0].is_ok() {
-		println!("'stable' update succeeded");
-	} else {
-		println!("'stable' update FAILED");
-	}
-	if result[1].is_ok() {
-		println!("'beta' update succeeded");
-	} else {
-		println!("'beta' update FAILED");
-	}
-	if result[2].is_ok() {
-		println!("'nightly' update succeeded");
-	} else {
-		println!("'nightly' update FAILED");
+	let max_name_length = toolchains.iter().map(|&(ref n,_)| n.len()).max().unwrap_or(0);
+	let padding_str: String = iter::repeat(' ').take(max_name_length).collect();
+	
+	println!("");
+	let mut t = term::stdout().unwrap();
+	for &(ref name, ref result) in &toolchains {
+		let _ = t.fg(term::color::BRIGHT_WHITE);
+		let _ = write!(t, "{}{}", &padding_str[0..(max_name_length-name.len())], name);
+		let _ = t.fg(term::color::WHITE);
+		let _ = write!(t, " update ");
+		if result.is_ok() {
+			let _ = t.fg(term::color::BRIGHT_GREEN);
+			let _ = writeln!(t, "succeeded");
+			let _ = t.fg(term::color::WHITE);
+		} else {
+			let _ = t.fg(term::color::BRIGHT_RED);
+			let _ = writeln!(t, "FAILED");
+			let _ = t.fg(term::color::WHITE);
+		}
 	}
+	println!("");
 
-	println!("stable revision:");
-	try!(show_tool_versions(&try!(cfg.get_toolchain("stable", false))));
-	println!("beta revision:");
-	try!(show_tool_versions(&try!(cfg.get_toolchain("beta", false))));
-	println!("nightly revision:");
-	try!(show_tool_versions(&try!(cfg.get_toolchain("nightly", false))));
+	for (name, _) in toolchains {
+		let _ = t.fg(term::color::BRIGHT_WHITE);
+		let _ = write!(t, "{}", name);
+		let _ = t.fg(term::color::WHITE);
+		let _ = writeln!(t, " revision:");
+		try!(show_tool_versions(&try!(cfg.get_toolchain(&name, false))));
+	}
 	Ok(())
 }
 

src/toolchain.rs

@@ -105,6 +105,9 @@ impl<'a> Toolchain<'a> {
 	pub fn is_custom(&self) -> bool {
 		dist::ToolchainDesc::from_str(&self.name).is_none()
 	}
+	pub fn is_tracking(&self) -> bool {
+		dist::ToolchainDesc::from_str(&self.name).map(|d| d.is_tracking()) == Some(true)
+	}
 
 	pub fn ensure_custom(&self) -> Result<()> {
 		if !self.is_custom() {