Add interactive advanced installation

This allows users to change --no-modify-path and --default-toolchain
from the interactive cli installer.

A typical session looks like

```
... snip ...

To cancel installation, type "n", or for more options type "a",
then press the Enter key to continue.

Press the Enter key to install Rust.
a

Selected installation options:

     default toolchain: stable
  modify PATH variable: yes

I'm going to ask you the value of each these installation options.
You may simply press the Enter key to accept the default.

Default toolchain? (stable/beta/nightly)
nightly

Modify PATH variable? (y/n)
n

That's it! We're ready to install Rust.

Selected installation options:

     default toolchain: nightly
  modify PATH variable: no

To cancel installation, type "n", or for more options type "a",
then press the Enter key to continue.

Press the Enter key to install Rust.

info: syncing channel updates for 'nightly-x86_64-unknown-linux-gnu'
info: default toolchain set to 'nightly'

  nightly unchanged - rustc 1.9.0-nightly (177905703 2016-04-08)

Rust is installed now. Great!

To get started you need Cargo's bin directory in your `PATH`
environment variable.

To configure your current shell run `source /home/brian/dev/.cargo/env`.
```

src/multirust-cli/common.rs

@@ -33,15 +33,14 @@ pub enum Confirm {
     Yes, No, Advanced
 }
 
-pub fn confirm_advanced(question: &str, default: Confirm) -> Result<Confirm> {
-    print!("{} ", question);
+pub fn confirm_advanced(default: Confirm) -> Result<Confirm> {
     let _ = std::io::stdout().flush();
     let input = try!(read_line());
 
     let r = match &*input {
-        "y" | "Y" => Confirm::Yes,
-        "n" | "N" => Confirm::No,
-        "a" | "A" => Confirm::Advanced,
+        "y" | "Y" | "yes" => Confirm::Yes,
+        "n" | "N" | "no" => Confirm::No,
+        "a" | "A" | "advanced" => Confirm::Advanced,
         "" => default,
         _ => Confirm::No,
     };
@@ -51,6 +50,40 @@ pub fn confirm_advanced(question: &str, default: Confirm) -> Result<Confirm> {
     Ok(r)
 }
 
+pub fn question_str(question: &str, default: &str) -> Result<String> {
+    println!("{}", question);
+    let _ = std::io::stdout().flush();
+    let input = try!(read_line());
+
+    println!("");
+
+    if input.is_empty() {
+        Ok(default.to_string())
+    } else {
+        Ok(input)
+    }
+}
+
+pub fn question_bool(question: &str, default: bool) -> Result<bool> {
+    println!("{}", question);
+
+    let _ = std::io::stdout().flush();
+    let input = try!(read_line());
+
+    println!("");
+
+    if input.is_empty() {
+        Ok(default)
+    } else {
+        match &*input {
+            "y" | "Y" | "yes" => Ok(true),
+            "n" | "N" | "no" => Ok(false),
+            _ => Ok(default)
+        }
+    }
+
+}
+
 pub fn read_line() -> Result<String> {
     let stdin = std::io::stdin();
     let stdin = stdin.lock();

src/multirust-cli/self_update.rs

@@ -76,8 +76,7 @@ these changes will be reverted.
 
 WARNING: This is an early beta. Expect breakage.
 
-To cancel installation, type "n" (for "nah, I don't want to install Rust"),
-or for more options type "a" (for "awesome advanced options"),
+To cancel installation, type "n", or for more options type "a",
 then press the Enter key to continue.
 
 Press the Enter key to install Rust."#
@@ -116,8 +115,9 @@ r"Rust is installed now. Great!
 
 To get started you need Cargo's bin directory in your `PATH`
 environment variable. Next time you log in this will be done
-automatically. To configure your current shell without logging out
-run `source {cargo_home}/env`.
+automatically.
+
+To configure your current shell run `source {cargo_home}/env`.
 "
     };
 }
@@ -129,7 +129,31 @@ r"Rust is installed now. Great!
 To get started you need Cargo's bin directory in your `PATH`
 environment variable. Future applications will automatically have the
 correct environment, but you may need to restart your current shell.
-" }; }
+"
+    };
+}
+
+macro_rules! post_install_msg_unix_no_modify_path {
+    () => {
+r"Rust is installed now. Great!
+
+To get started you need Cargo's bin directory in your `PATH`
+environment variable.
+
+To configure your current shell run `source {cargo_home}/env`.
+"
+    };
+}
+
+macro_rules! post_install_msg_win_no_modify_path {
+    () => {
+r"Rust is installed now. Great!
+
+To get started you need Cargo's bin directory in your `PATH`
+environment variable. This has not been done automatically.
+"
+    };
+}
 
 macro_rules! pre_uninstall_msg {
     () => {
@@ -172,7 +196,8 @@ pub fn install(no_prompt: bool, verbose: bool,
 
     if !no_prompt {
         let ref msg = try!(pre_install_msg(opts.no_modify_path));
-        match try!(common::confirm_advanced(msg, Confirm::Yes)) {
+        println!("{}", msg);
+        match try!(common::confirm_advanced(Confirm::Yes)) {
             Confirm::No => {
                 info!("aborting installation");
                 return Ok(());
@@ -203,7 +228,11 @@ pub fn install(no_prompt: bool, verbose: bool,
 
         if cfg!(unix) {
             let ref env_file = try!(utils::cargo_home()).join("env");
-            let ref env_str = try!(shell_export_string());
+            let ref env_str = format!(
+                "{}\n\
+                 printf \"PATH environment variable set.\\n\"
+                 printf \"You're ready to Rust!\\n\\n\"",
+                try!(shell_export_string()));
             try!(utils::write_file("env", env_file, env_str));
         }
 
@@ -228,12 +257,22 @@ pub fn install(no_prompt: bool, verbose: bool,
 
     // More helpful advice, skip if -y
     if !no_prompt {
-        if cfg!(unix) {
-            let cargo_home = try!(canonical_cargo_home());
-            println!(post_install_msg_unix!(),
-                     cargo_home = cargo_home);
+        if !selected_opts.no_modify_path {
+            if cfg!(unix) {
+                let cargo_home = try!(canonical_cargo_home());
+                println!(post_install_msg_unix!(),
+                         cargo_home = cargo_home);
+            } else {
+                println!(post_install_msg_win!());
+            }
         } else {
-            println!(post_install_msg_win!());
+            if cfg!(unix) {
+                let cargo_home = try!(canonical_cargo_home());
+                println!(post_install_msg_unix_no_modify_path!(),
+                         cargo_home = cargo_home);
+            } else {
+                println!(post_install_msg_win_no_modify_path!());
+            }
         }
 
         // On windows, where installation happens in a console
@@ -279,8 +318,62 @@ fn pre_install_msg(no_modify_path: bool) -> Result<String> {
 }
 
 // Interactive editing of the install options
-fn advanced_install(opts: InstallOpts) -> Result<Option<InstallOpts>> {
-    unimplemented!()
+fn advanced_install(mut opts: InstallOpts) -> Result<Option<InstallOpts>> {
+
+    fn print_opts(opts: &InstallOpts) {
+        println!(
+            r"Selected installation options:
+
+     default toolchain: {}
+  modify PATH variable: {}
+",
+            opts.default_toolchain,
+            if !opts.no_modify_path { "yes" } else { "no" }
+            );
+    }
+
+    loop {
+
+        print_opts(&opts);
+
+        println!(
+            "I'm going to ask you the value of each these installation options.\n\
+             You may simply press the Enter key to accept the default.");
+
+        println!("");
+
+        opts.default_toolchain = try!(common::question_str(
+            "Default toolchain? (stable/beta/nightly)",
+            &opts.default_toolchain));
+
+        opts.no_modify_path = !try!(common::question_bool(
+            "Modify PATH variable? (y/n)",
+            !opts.no_modify_path));
+
+        println!("That's it! We're ready to install Rust.");
+        println!("");
+
+        print_opts(&opts);
+
+        println!(
+r#"To cancel installation, type "n", or for more options type "a",
+then press the Enter key to continue.
+
+Press the Enter key to install Rust. "#);
+
+        match try!(common::confirm_advanced(Confirm::Yes)) {
+            Confirm::No => {
+                info!("aborting installation");
+                return Ok(None);
+            }
+            Confirm::Yes => {
+                return Ok(Some(opts));
+            }
+            Confirm::Advanced => {
+                continue;
+            }
+        }
+    }
 }
 
 // Before multirust-rs installed bins to $CARGO_HOME/bin it installed
@@ -340,11 +433,21 @@ fn install_bins() -> Result<()> {
 
 fn maybe_install_rust(toolchain_str: &str, verbose: bool) -> Result<()> {
     let ref cfg = try!(common::set_globals(verbose));
-    let toolchain = try!(cfg.get_toolchain(toolchain_str, false));
-    let status = try!(toolchain.install_from_dist());
-    try!(cfg.set_default(toolchain_str));
-    println!("");
-    try!(common::show_channel_update(cfg, toolchain_str, Ok(status)));
+
+    // If there is already an install, then `toolchain_str` may not be
+    // a toolchain the user actually wants. Don't do anything.  FIXME:
+    // This logic should be part of InstallOpts so that it isn't
+    // possible to select a toolchain then have it not be installed.
+    if try!(cfg.find_default()).is_none() {
+        let toolchain = try!(cfg.get_toolchain(toolchain_str, false));
+        let status = try!(toolchain.install_from_dist());
+        try!(cfg.set_default(toolchain_str));
+        println!("");
+        try!(common::show_channel_update(cfg, toolchain_str, Ok(status)));
+    } else {
+        info!("updating existing rustup installation");
+        println!("");
+    }
 
     Ok(())
 }

tests/cli-install-interactive.rs

@@ -10,7 +10,8 @@ use std::sync::Mutex;
 use std::process::Stdio;
 use std::io::Write;
 use multirust_mock::clitools::{self, Config, Scenario,
-                               SanitizedOutput};
+                               SanitizedOutput,
+                               expect_stdout_ok};
 use multirust_mock::{get_path, restore_path};
 
 pub fn setup(f: &Fn(&Config)) {
@@ -73,12 +74,14 @@ fn blank_lines_around_stderr_log_output_install() {
     setup(&|config| {
         let out = run_input(config, &["rustup-setup"], "\n\n");
 
-        // During an interactive session, after "Continue?"
-        // there is a blank line that comes from the user pressing enter,
-        // then log output on stderr, then an explicit blank line on stdout
+        // During an interactive session, after "Press the Enter
+        // key..."  the UI emits a blank line, then there is a blank
+        // line that comes from the user pressing enter, then log
+        // output on stderr, then an explicit blank line on stdout
         // before printing $toolchain installed
         assert!(out.stdout.contains(r"
-Press the Enter key to install Rust. 
+Press the Enter key to install Rust.
+
 
   stable installed - 1.1.0 (hash-s-2)
 
@@ -93,12 +96,9 @@ fn blank_lines_around_stderr_log_output_update() {
         run_input(config, &["rustup-setup"], "\n\n");
         let out = run_input(config, &["rustup-setup"], "\n\n");
 
-        // Here again the user generates one blank line, then there
-        // are lines of stderr logs, then one blank line on stdout.
         assert!(out.stdout.contains(r"
-Press the Enter key to install Rust. 
+Press the Enter key to install Rust.
 
-  stable unchanged - 1.1.0 (hash-s-2)
 
 Rust is installed now. Great!
 "));
@@ -129,8 +129,55 @@ fn with_no_modify_path() {
 
 #[test]
 fn with_non_default_toolchain() {
+    setup(&|config| {
+        let out = run_input(config, &["rustup-setup", "--default-toolchain=nightly"], "\n\n");
+        assert!(out.ok);
+
+        expect_stdout_ok(config, &["rustup", "show"], "nightly");
+    });
 }
 
 #[test]
-fn with_no_modify_path_and_non_default_toolchain() {
+fn set_nightly_toolchain() {
+    setup(&|config| {
+        let out = run_input(config, &["rustup-setup"],
+                            "a\nnightly\n\n\n\n");
+        assert!(out.ok);
+
+        expect_stdout_ok(config, &["rustup", "show"], "nightly");
+    });
+}
+
+#[test]
+fn set_no_modify_path() {
+    setup(&|config| {
+        let out = run_input(config, &["rustup-setup"],
+                            "a\n\nno\n\n\n");
+        assert!(out.ok);
+
+        if cfg!(unix) {
+            assert!(!config.homedir.join(".profile").exists());
+        }
+    });
+}
+
+#[test]
+fn set_nightly_toolchain_and_unset() {
+    setup(&|config| {
+        let out = run_input(config, &["rustup-setup"],
+                            "a\nnightly\n\na\nbeta\n\n\n\n");
+        assert!(out.ok);
+
+        expect_stdout_ok(config, &["rustup", "show"], "beta");
+    });
+}
+
+#[test]
+fn user_says_nope_after_advanced_install() {
+    setup(&|config| {
+        let out = run_input(config, &["rustup-setup"],
+                            "a\n\n\nn\n\n");
+        assert!(out.ok);
+        assert!(!config.cargodir.join("bin").exists());
+    });
 }

tests/cli-self-update.rs

@@ -721,7 +721,7 @@ fn reinstall_exact() {
         expect_ok_ex(config, &["rustup-setup", "-y"],
 r"
 ",
-r"info: updating existing installation
+r"info: updating existing rustup installation
 "
                   );
     });
@@ -740,7 +740,7 @@ fn produces_env_file_on_unix() {
         assert!(cmd.output().unwrap().status.success());
         let ref envfile = config.homedir.join(".cargo/env");
         let envfile = raw::read_file(envfile).unwrap();
-        assert_eq!(r#"export PATH="$HOME/.cargo/bin:$PATH""#, envfile);
+        assert!(envfile.contains(r#"export PATH="$HOME/.cargo/bin:$PATH""#));
     });
 }