Make the CLI code a library

In order to do in-process tests the CLI code must be (mostly) a library.

Thus:
 - rustup-init should moves to the usual place to make this visually
   distinct
 - cli.rs as a mod to define the import
 - 2018 edition changes to the cli code which had not been updated
 - export the needed parts of the cli code such that rustup-init can
   import them

Author: rbtcollins

Cargo.toml

@@ -105,10 +105,6 @@ name = "rustup"
 path = "src/lib.rs"
 test = false # no unit tests
 
-[[bin]]
-name = "rustup-init"
-path = "src/cli/main.rs"
-
 [profile.release]
 lto = true
 codegen-units = 1

src/cli/main.rs renamed to src/bin/rustup-init.rs

@@ -14,30 +14,20 @@
 
 #![recursion_limit = "1024"]
 
-#[macro_use]
-mod log;
-mod common;
-mod download_tracker;
-mod errors;
-mod help;
-mod job;
-mod markdown;
-mod proxy_mode;
-mod rustup_mode;
-mod self_update;
-mod setup_mode;
-mod term2;
-mod topical_doc;
-
-use crate::errors::*;
-use rustup::env_var::RUST_RECURSION_COUNT_MAX;
-use rustup::utils::utils;
-
 use std::env;
 use std::path::PathBuf;
 
 use rs_tracing::*;
 
+use rustup::cli::common;
+use rustup::cli::errors::*;
+use rustup::cli::proxy_mode;
+use rustup::cli::rustup_mode;
+use rustup::cli::self_update;
+use rustup::cli::setup_mode;
+use rustup::env_var::RUST_RECURSION_COUNT_MAX;
+use rustup::utils::utils;
+
 fn main() {
     if let Err(ref e) = run_rustup() {
         common::report_error(e);

src/cli.rs

@@ -0,0 +1,15 @@
+/// The CLI specific code lives in the cli module and sub-modules.
+#[macro_use]
+pub mod log;
+pub mod common;
+mod download_tracker;
+pub mod errors;
+pub mod help;
+mod job;
+mod markdown;
+pub mod proxy_mode;
+pub mod rustup_mode;
+pub mod self_update;
+pub mod setup_mode;
+mod term2;
+mod topical_doc;

src/cli/common.rs

@@ -1,23 +1,25 @@
 //! Just a dumping ground for cli stuff
 
-use crate::errors::*;
-use crate::self_update;
-use crate::term2;
-use git_testament::{git_testament, render_testament};
-use lazy_static::lazy_static;
-use rustup::dist::notifications as dist_notifications;
-use rustup::toolchain::DistributableToolchain;
-use rustup::utils::notifications as util_notifications;
-use rustup::utils::notify::NotificationLevel;
-use rustup::utils::utils;
-use rustup::{Cfg, Notification, Toolchain, UpdateStatus};
 use std::fs;
 use std::io::{BufRead, ErrorKind, Write};
 use std::path::Path;
 use std::sync::Arc;
 use std::{cmp, env, iter};
+
+use git_testament::{git_testament, render_testament};
+use lazy_static::lazy_static;
 use term2::Terminal;
 
+use super::errors::*;
+use super::self_update;
+use super::term2;
+use crate::dist::notifications as dist_notifications;
+use crate::toolchain::DistributableToolchain;
+use crate::utils::notifications as util_notifications;
+use crate::utils::notify::NotificationLevel;
+use crate::utils::utils;
+use crate::{Cfg, Notification, Toolchain, UpdateStatus};
+
 pub const WARN_COMPLETE_PROFILE: &str = "downloading with complete profile isn't recommended unless you are a developer of the rust language";
 
 pub fn confirm(question: &str, default: bool) -> Result<bool> {
@@ -148,9 +150,10 @@ impl NotifyOnConsole {
 }
 
 pub fn set_globals(verbose: bool, quiet: bool) -> Result<Cfg> {
-    use crate::download_tracker::DownloadTracker;
     use std::cell::RefCell;
 
+    use super::download_tracker::DownloadTracker;
+
     let download_tracker = RefCell::new(DownloadTracker::new().with_display_progress(!quiet));
     let console_notifier = RefCell::new(NotifyOnConsole {
         verbose,
@@ -168,14 +171,14 @@ pub fn set_globals(verbose: bool, quiet: bool) -> Result<Cfg> {
 pub fn show_channel_update(
     cfg: &Cfg,
     name: &str,
-    updated: rustup::Result<UpdateStatus>,
+    updated: crate::Result<UpdateStatus>,
 ) -> Result<()> {
     show_channel_updates(cfg, vec![(name.to_string(), updated)])
 }
 
 fn show_channel_updates(
     cfg: &Cfg,
-    toolchains: Vec<(String, rustup::Result<UpdateStatus>)>,
+    toolchains: Vec<(String, crate::Result<UpdateStatus>)>,
 ) -> Result<()> {
     let data = toolchains.into_iter().map(|(name, result)| {
         let toolchain = cfg.get_toolchain(&name, false).unwrap();
@@ -348,7 +351,7 @@ where
 pub fn list_targets(toolchain: &Toolchain<'_>) -> Result<()> {
     let mut t = term2::stdout();
     let distributable = DistributableToolchain::new(&toolchain)
-        .chain_err(|| rustup::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
+        .chain_err(|| crate::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
     let components = distributable.list_components()?;
     for component in components {
         if component.component.short_name_in_manifest() == "rust-std" {
@@ -373,7 +376,7 @@ pub fn list_targets(toolchain: &Toolchain<'_>) -> Result<()> {
 pub fn list_installed_targets(toolchain: &Toolchain<'_>) -> Result<()> {
     let mut t = term2::stdout();
     let distributable = DistributableToolchain::new(&toolchain)
-        .chain_err(|| rustup::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
+        .chain_err(|| crate::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
     let components = distributable.list_components()?;
     for component in components {
         if component.component.short_name_in_manifest() == "rust-std" {
@@ -393,7 +396,7 @@ pub fn list_installed_targets(toolchain: &Toolchain<'_>) -> Result<()> {
 pub fn list_components(toolchain: &Toolchain<'_>) -> Result<()> {
     let mut t = term2::stdout();
     let distributable = DistributableToolchain::new(&toolchain)
-        .chain_err(|| rustup::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
+        .chain_err(|| crate::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
     let components = distributable.list_components()?;
     for component in components {
         let name = component.name;
@@ -412,7 +415,7 @@ pub fn list_components(toolchain: &Toolchain<'_>) -> Result<()> {
 pub fn list_installed_components(toolchain: &Toolchain<'_>) -> Result<()> {
     let mut t = term2::stdout();
     let distributable = DistributableToolchain::new(&toolchain)
-        .chain_err(|| rustup::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
+        .chain_err(|| crate::ErrorKind::ComponentsUnsupported(toolchain.name().to_string()))?;
     let components = distributable.list_components()?;
     for component in components {
         if component.installed {
@@ -586,7 +589,7 @@ pub fn report_error(e: &Error) {
     }
 }
 
-pub fn ignorable_error(error: crate::errors::Error, no_prompt: bool) -> Result<()> {
+pub fn ignorable_error(error: super::errors::Error, no_prompt: bool) -> Result<()> {
     report_error(&error);
     if no_prompt {
         warn!("continuing (because the -y flag is set and the error is ignorable)");

src/cli/download_tracker.rs

@@ -1,15 +1,17 @@
-use crate::term2;
-use rustup::dist::Notification as In;
-use rustup::utils::tty;
-use rustup::utils::units::{Size, Unit, UnitMode};
-use rustup::utils::Notification as Un;
-use rustup::Notification;
 use std::collections::VecDeque;
 use std::fmt;
 use std::io::Write;
 use std::time::{Duration, Instant};
+
 use term::Terminal;
 
+use super::term2;
+use crate::dist::Notification as In;
+use crate::utils::tty;
+use crate::utils::units::{Size, Unit, UnitMode};
+use crate::utils::Notification as Un;
+use crate::Notification;
+
 /// Keep track of this many past download amounts
 const DOWNLOAD_TRACK_COUNT: usize = 5;
 

src/cli/errors.rs

@@ -2,21 +2,21 @@
 #![allow(dead_code)]
 #![allow(deprecated)] // because of `Error::description` deprecation in `error_chain`
 
-use crate::rustup_mode::CompletionCommand;
-
 use std::io;
 use std::path::PathBuf;
 
 use clap::Shell;
 use error_chain::error_chain;
 use lazy_static::lazy_static;
 use regex::Regex;
-use rustup::dist::temp;
 use strsim::damerau_levenshtein;
 
+use super::rustup_mode::CompletionCommand;
+use crate::dist::temp;
+
 error_chain! {
     links {
-        Rustup(rustup::Error, rustup::ErrorKind);
+        Rustup(crate::Error, crate::ErrorKind);
     }
 
     foreign_links {

src/cli/log.rs

@@ -1,24 +1,25 @@
-use crate::term2;
 use std::fmt;
 use std::io::Write;
 use term2::Terminal;
 
+use super::term2;
+
 macro_rules! warn {
-    ( $ ( $ arg : tt ) * ) => ( $crate::log::warn_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
+    ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::warn_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
 }
 macro_rules! err {
-    ( $ ( $ arg : tt ) * ) => ( $crate::log::err_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
+    ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::err_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
 }
 macro_rules! info {
-    ( $ ( $ arg : tt ) * ) => ( $crate::log::info_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
+    ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::info_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
 }
 
 macro_rules! verbose {
-    ( $ ( $ arg : tt ) * ) => ( $crate::log::verbose_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
+    ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::verbose_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
 }
 
 macro_rules! debug {
-    ( $ ( $ arg : tt ) * ) => ( $crate::log::debug_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
+    ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::debug_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
 }
 
 pub fn warn_fmt(args: fmt::Arguments<'_>) {

src/cli/markdown.rs

@@ -1,10 +1,11 @@
 // Write Markdown to the terminal
 
-use crate::term2::{color, Attr, Terminal};
 use std::io;
 
 use pulldown_cmark::{Event, Tag};
 
+use super::term2::{color, Attr, Terminal};
+
 // Handles the wrapping of text written to the console
 struct LineWrapper<'a, T: Terminal> {
     indent: u32,

src/cli/proxy_mode.rs

@@ -1,16 +1,18 @@
-use crate::common::set_globals;
-use crate::errors::*;
-use crate::job;
-use rustup::command::run_command_for_dir;
-use rustup::utils::utils::{self, ExitCode};
-use rustup::Cfg;
 use std::env;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::process;
 
+use super::common::set_globals;
+use super::errors::*;
+use super::job;
+use super::self_update;
+use crate::command::run_command_for_dir;
+use crate::utils::utils::{self, ExitCode};
+use crate::Cfg;
+
 pub fn main() -> Result<()> {
-    crate::self_update::cleanup_self_updater()?;
+    self_update::cleanup_self_updater()?;
 
     let ExitCode(c) = {
         let _setup = job::setup();