Move most of the root package into a subcrate. (#1445)

This improves incremental build time when working on what was previously
the root package. For example, previously all plugins would be rebuilt
with a change to `src/commands/classified/external.rs`, but now only
`nu-cli` will have to be rebuilt (and anything that depends on it).

crates/nu-cli/src/env/environment.rs

@@ -0,0 +1,289 @@
+use crate::data::config::Conf;
+use indexmap::{indexmap, IndexSet};
+use nu_protocol::{UntaggedValue, Value};
+use std::ffi::OsString;
+use std::fmt::Debug;
+
+pub trait Env: Debug + Send {
+    fn env(&self) -> Option<Value>;
+    fn path(&self) -> Option<Value>;
+
+    fn add_env(&mut self, key: &str, value: &str);
+    fn add_path(&mut self, new_path: OsString);
+}
+
+impl Env for Box<dyn Env> {
+    fn env(&self) -> Option<Value> {
+        (**self).env()
+    }
+
+    fn path(&self) -> Option<Value> {
+        (**self).path()
+    }
+
+    fn add_env(&mut self, key: &str, value: &str) {
+        (**self).add_env(key, value);
+    }
+
+    fn add_path(&mut self, new_path: OsString) {
+        (**self).add_path(new_path);
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Environment {
+    environment_vars: Option<Value>,
+    path_vars: Option<Value>,
+}
+
+impl Environment {
+    pub fn new() -> Environment {
+        Environment {
+            environment_vars: None,
+            path_vars: None,
+        }
+    }
+
+    pub fn from_config<T: Conf>(configuration: &T) -> Environment {
+        let env = configuration.env();
+        let path = configuration.path();
+
+        Environment {
+            environment_vars: env,
+            path_vars: path,
+        }
+    }
+
+    pub fn morph<T: Conf>(&mut self, configuration: &T) {
+        self.environment_vars = configuration.env();
+        self.path_vars = configuration.path();
+    }
+}
+
+impl Env for Environment {
+    fn env(&self) -> Option<Value> {
+        if let Some(vars) = &self.environment_vars {
+            return Some(vars.clone());
+        }
+
+        None
+    }
+
+    fn path(&self) -> Option<Value> {
+        if let Some(vars) = &self.path_vars {
+            return Some(vars.clone());
+        }
+
+        None
+    }
+
+    fn add_env(&mut self, key: &str, value: &str) {
+        let value = UntaggedValue::string(value);
+
+        let new_envs = {
+            if let Some(Value {
+                value: UntaggedValue::Row(ref envs),
+                ref tag,
+            }) = self.environment_vars
+            {
+                let mut new_envs = envs.clone();
+
+                if !new_envs.contains_key(key) {
+                    new_envs.insert_data_at_key(key, value.into_value(tag.clone()));
+                }
+
+                Value {
+                    value: UntaggedValue::Row(new_envs),
+                    tag: tag.clone(),
+                }
+            } else {
+                UntaggedValue::Row(indexmap! { key.into() => value.into_untagged_value() }.into())
+                    .into_untagged_value()
+            }
+        };
+
+        self.environment_vars = Some(new_envs);
+    }
+
+    fn add_path(&mut self, paths: std::ffi::OsString) {
+        let new_paths = {
+            if let Some(Value {
+                value: UntaggedValue::Table(ref current_paths),
+                ref tag,
+            }) = self.path_vars
+            {
+                let mut new_paths = current_paths.clone();
+
+                let new_path_candidates = std::env::split_paths(&paths).map(|path| {
+                    UntaggedValue::string(path.to_string_lossy()).into_value(tag.clone())
+                });
+
+                new_paths.extend(new_path_candidates);
+
+                let paths: IndexSet<Value> = new_paths.into_iter().collect();
+
+                Value {
+                    value: UntaggedValue::Table(paths.into_iter().collect()),
+                    tag: tag.clone(),
+                }
+            } else {
+                let p = paths.into_string().unwrap_or_else(|_| String::from(""));
+                let p = UntaggedValue::string(p).into_untagged_value();
+                UntaggedValue::Table(vec![p]).into_untagged_value()
+            }
+        };
+
+        self.path_vars = Some(new_paths);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Env, Environment};
+    use crate::data::config::{tests::FakeConfig, Conf};
+    use nu_protocol::UntaggedValue;
+    use nu_test_support::fs::Stub::FileWithContent;
+    use nu_test_support::playground::Playground;
+
+    #[test]
+    fn picks_up_environment_variables_from_configuration() {
+        Playground::setup("environment_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    mosquetero_1 = "Andrés N. Robalino"
+                    mosquetero_2 = "Jonathan Turner"
+                    mosquetero_3 = "Yehuda katz"
+                    mosquetero_4 = "Jason Gedge"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let actual = Environment::from_config(&fake_config);
+
+            assert_eq!(actual.env(), fake_config.env());
+        });
+    }
+
+    #[test]
+    fn picks_up_path_variables_from_configuration() {
+        Playground::setup("environment_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let actual = Environment::from_config(&fake_config);
+
+            assert_eq!(actual.path(), fake_config.path());
+        });
+    }
+
+    #[test]
+    fn updates_env_variable() {
+        Playground::setup("environment_test_3", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_env("USER", "NUNO");
+
+            assert_eq!(
+                actual.env(),
+                Some(
+                    UntaggedValue::row(
+                        indexmap! {
+                            "USER".into() => UntaggedValue::string("NUNO").into_untagged_value(),
+                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
+                        }
+                    ).into_untagged_value()
+                )
+            );
+        });
+    }
+
+    #[test]
+    fn does_not_update_env_variable_if_it_exists() {
+        Playground::setup("environment_test_4", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_env("SHELL", "/usr/bin/sh");
+
+            assert_eq!(
+                actual.env(),
+                Some(
+                    UntaggedValue::row(
+                        indexmap! {
+                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
+                        }
+                    ).into_untagged_value()
+                )
+            );
+        });
+    }
+
+    #[test]
+    fn updates_path_variable() {
+        Playground::setup("environment_test_5", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_path(std::ffi::OsString::from("/path/to/be/added"));
+
+            assert_eq!(
+                actual.path(),
+                Some(
+                    UntaggedValue::table(&vec![
+                        UntaggedValue::string("/Users/andresrobalino/.volta/bin")
+                            .into_untagged_value(),
+                        UntaggedValue::string("/users/mosqueteros/bin").into_untagged_value(),
+                        UntaggedValue::string("/path/to/be/added").into_untagged_value(),
+                    ])
+                    .into_untagged_value()
+                )
+            );
+        });
+    }
+}

crates/nu-cli/src/env/environment_syncer.rs

@@ -0,0 +1,463 @@
+use crate::context::Context;
+use crate::data::config::{Conf, NuConfig};
+use crate::env::environment::{Env, Environment};
+use parking_lot::Mutex;
+use std::sync::Arc;
+
+pub struct EnvironmentSyncer {
+    pub env: Arc<Mutex<Box<Environment>>>,
+    pub config: Arc<Box<dyn Conf>>,
+}
+
+impl Default for EnvironmentSyncer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EnvironmentSyncer {
+    pub fn new() -> EnvironmentSyncer {
+        EnvironmentSyncer {
+            env: Arc::new(Mutex::new(Box::new(Environment::new()))),
+            config: Arc::new(Box::new(NuConfig::new())),
+        }
+    }
+
+    #[cfg(test)]
+    pub fn set_config(&mut self, config: Box<dyn Conf>) {
+        self.config = Arc::new(config);
+    }
+
+    pub fn load_environment(&mut self) {
+        let config = self.config.clone();
+
+        self.env = Arc::new(Mutex::new(Box::new(Environment::from_config(&*config))));
+    }
+
+    pub fn reload(&mut self) {
+        self.config.reload();
+
+        let mut environment = self.env.lock();
+        environment.morph(&*self.config);
+    }
+
+    pub fn sync_env_vars(&mut self, ctx: &mut Context) {
+        let mut environment = self.env.lock();
+
+        if environment.env().is_some() {
+            for (name, value) in ctx.with_host(|host| host.vars()) {
+                if name != "path" && name != "PATH" {
+                    // account for new env vars present in the current session
+                    // that aren't loaded from config.
+                    environment.add_env(&name, &value);
+
+                    // clear the env var from the session
+                    // we are about to replace them
+                    ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(name)));
+                }
+            }
+
+            if let Some(variables) = environment.env() {
+                for var in nu_value_ext::row_entries(&variables) {
+                    if let Ok(string) = var.1.as_string() {
+                        ctx.with_host(|host| {
+                            host.env_set(
+                                std::ffi::OsString::from(var.0),
+                                std::ffi::OsString::from(string),
+                            )
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn sync_path_vars(&mut self, ctx: &mut Context) {
+        let mut environment = self.env.lock();
+
+        if environment.path().is_some() {
+            let native_paths = ctx.with_host(|host| host.env_get(std::ffi::OsString::from("PATH")));
+
+            if let Some(native_paths) = native_paths {
+                environment.add_path(native_paths);
+
+                ctx.with_host(|host| {
+                    host.env_rm(std::ffi::OsString::from("PATH"));
+                });
+            }
+
+            if let Some(new_paths) = environment.path() {
+                let prepared = std::env::join_paths(
+                    nu_value_ext::table_entries(&new_paths)
+                        .map(|p| p.as_string())
+                        .filter_map(Result::ok),
+                );
+
+                if let Ok(paths_ready) = prepared {
+                    ctx.with_host(|host| {
+                        host.env_set(std::ffi::OsString::from("PATH"), paths_ready);
+                    });
+                }
+            }
+        }
+    }
+
+    #[cfg(test)]
+    pub fn clear_env_vars(&mut self, ctx: &mut Context) {
+        for (key, _value) in ctx.with_host(|host| host.vars()) {
+            if key != "path" && key != "PATH" {
+                ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(key)));
+            }
+        }
+    }
+
+    #[cfg(test)]
+    pub fn clear_path_var(&mut self, ctx: &mut Context) {
+        ctx.with_host(|host| host.env_rm(std::ffi::OsString::from("PATH")));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EnvironmentSyncer;
+    use crate::context::Context;
+    use crate::data::config::tests::FakeConfig;
+    use crate::env::environment::Env;
+    use nu_errors::ShellError;
+    use nu_test_support::fs::Stub::FileWithContent;
+    use nu_test_support::playground::Playground;
+    use parking_lot::Mutex;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+
+    #[test]
+    fn syncs_env_if_new_env_entry_in_session_is_not_in_configuration_file() -> Result<(), ShellError>
+    {
+        let mut ctx = Context::basic()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(crate::env::host::FakeHost::new())));
+
+        let expected = vec![
+            (
+                "SHELL".to_string(),
+                "/usr/bin/you_already_made_the_nu_choice".to_string(),
+            ),
+            ("USER".to_string(), "NUNO".to_string()),
+        ];
+
+        Playground::setup("syncs_env_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            // Here, the environment variables from the current session
+            // are cleared since we will load and set them from the
+            // configuration file (if any)
+            actual.clear_env_vars(&mut ctx);
+
+            // We explicitly simulate and add the USER variable to the current
+            // session's environment variables with the value "NUNO".
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("USER"),
+                    std::ffi::OsString::from("NUNO"),
+                )
+            });
+
+            // Nu loads the environment variables from the configuration file (if any)
+            actual.load_environment();
+
+            // By this point, Nu has already loaded the environment variables
+            // stored in the configuration file. Before continuing we check
+            // if any new environment variables have been added from the ones loaded
+            // in the configuration file.
+            //
+            // Nu sees the missing "USER" variable and accounts for it.
+            actual.sync_env_vars(&mut ctx);
+
+            // Confirms session environment variables are replaced from Nu configuration file
+            // including the newer one accounted for.
+            ctx.with_host(|test_host| {
+                let var_user = test_host
+                    .env_get(std::ffi::OsString::from("USER"))
+                    .expect("Couldn't get USER var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let var_shell = test_host
+                    .env_get(std::ffi::OsString::from("SHELL"))
+                    .expect("Couldn't get SHELL var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let actual = vec![
+                    ("SHELL".to_string(), var_shell),
+                    ("USER".to_string(), var_user),
+                ];
+
+                assert_eq!(actual, expected);
+            });
+
+            // Now confirm in-memory environment variables synced appropiately
+            // including the newer one accounted for.
+            let environment = actual.env.lock();
+
+            let vars = nu_value_ext::row_entries(
+                &environment.env().expect("No variables in the environment."),
+            )
+            .map(|(name, value)| {
+                (
+                    name.to_string(),
+                    value.as_string().expect("Couldn't convert to string"),
+                )
+            })
+            .collect::<Vec<_>>();
+
+            assert_eq!(vars, expected);
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn nu_envs_have_higher_priority_and_does_not_get_overwritten() -> Result<(), ShellError> {
+        let mut ctx = Context::basic()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(crate::env::host::FakeHost::new())));
+
+        let expected = vec![(
+            "SHELL".to_string(),
+            "/usr/bin/you_already_made_the_nu_choice".to_string(),
+        )];
+
+        Playground::setup("syncs_env_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            actual.clear_env_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("SHELL"),
+                    std::ffi::OsString::from("/usr/bin/sh"),
+                )
+            });
+
+            actual.load_environment();
+            actual.sync_env_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let var_shell = test_host
+                    .env_get(std::ffi::OsString::from("SHELL"))
+                    .expect("Couldn't get SHELL var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let actual = vec![("SHELL".to_string(), var_shell)];
+
+                assert_eq!(actual, expected);
+            });
+
+            let environment = actual.env.lock();
+
+            let vars = nu_value_ext::row_entries(
+                &environment.env().expect("No variables in the environment."),
+            )
+            .map(|(name, value)| {
+                (
+                    name.to_string(),
+                    value.as_string().expect("Couldn't convert to string"),
+                )
+            })
+            .collect::<Vec<_>>();
+
+            assert_eq!(vars, expected);
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn syncs_path_if_new_path_entry_in_session_is_not_in_configuration_file(
+    ) -> Result<(), ShellError> {
+        let mut ctx = Context::basic()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(crate::env::host::FakeHost::new())));
+
+        let expected = std::env::join_paths(vec![
+            PathBuf::from("/Users/andresrobalino/.volta/bin"),
+            PathBuf::from("/Users/mosqueteros/bin"),
+            PathBuf::from("/path/to/be/added"),
+        ])
+        .expect("Couldn't join paths.")
+        .into_string()
+        .expect("Couldn't convert to string.");
+
+        Playground::setup("syncs_path_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            // Here, the environment variables from the current session
+            // are cleared since we will load and set them from the
+            // configuration file (if any)
+            actual.clear_path_var(&mut ctx);
+
+            // We explicitly simulate and add the PATH variable to the current
+            // session with the path "/path/to/be/added".
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("PATH"),
+                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
+                        .expect("Couldn't join paths."),
+                )
+            });
+
+            // Nu loads the path variables from the configuration file (if any)
+            actual.load_environment();
+
+            // By this point, Nu has already loaded environment path variable
+            // stored in the configuration file. Before continuing we check
+            // if any new paths have been added from the ones loaded in the
+            // configuration file.
+            //
+            // Nu sees the missing "/path/to/be/added" and accounts for it.
+            actual.sync_path_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let actual = test_host
+                    .env_get(std::ffi::OsString::from("PATH"))
+                    .expect("Couldn't get PATH var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                assert_eq!(actual, expected);
+            });
+
+            let environment = actual.env.lock();
+
+            let paths = std::env::join_paths(
+                &nu_value_ext::table_entries(
+                    &environment
+                        .path()
+                        .expect("No path variable in the environment."),
+                )
+                .map(|value| value.as_string().expect("Couldn't convert to string"))
+                .map(PathBuf::from)
+                .collect::<Vec<_>>(),
+            )
+            .expect("Couldn't join paths.")
+            .into_string()
+            .expect("Couldn't convert to string.");
+
+            assert_eq!(paths, expected);
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn nu_paths_have_higher_priority_and_new_paths_get_appended_to_the_end(
+    ) -> Result<(), ShellError> {
+        let mut ctx = Context::basic()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(crate::env::host::FakeHost::new())));
+
+        let expected = std::env::join_paths(vec![
+            PathBuf::from("/Users/andresrobalino/.volta/bin"),
+            PathBuf::from("/Users/mosqueteros/bin"),
+            PathBuf::from("/path/to/be/added"),
+        ])
+        .expect("Couldn't join paths.")
+        .into_string()
+        .expect("Couldn't convert to string.");
+
+        Playground::setup("syncs_path_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            actual.clear_path_var(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("PATH"),
+                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
+                        .expect("Couldn't join paths."),
+                )
+            });
+
+            actual.load_environment();
+            actual.sync_path_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let actual = test_host
+                    .env_get(std::ffi::OsString::from("PATH"))
+                    .expect("Couldn't get PATH var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                assert_eq!(actual, expected);
+            });
+
+            let environment = actual.env.lock();
+
+            let paths = std::env::join_paths(
+                &nu_value_ext::table_entries(
+                    &environment
+                        .path()
+                        .expect("No path variable in the environment."),
+                )
+                .map(|value| value.as_string().expect("Couldn't convert to string"))
+                .map(PathBuf::from)
+                .collect::<Vec<_>>(),
+            )
+            .expect("Couldn't join paths.")
+            .into_string()
+            .expect("Couldn't convert to string.");
+
+            assert_eq!(paths, expected);
+        });
+
+        Ok(())
+    }
+}

crates/nu-cli/src/env/host.rs

@@ -0,0 +1,212 @@
+use crate::prelude::*;
+#[cfg(test)]
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use std::ffi::OsString;
+use std::fmt::Debug;
+
+pub trait Host: Debug + Send {
+    fn out_terminal(&self) -> Option<Box<term::StdoutTerminal>>;
+    fn err_terminal(&self) -> Option<Box<term::StderrTerminal>>;
+
+    fn out_termcolor(&self) -> termcolor::StandardStream;
+    fn err_termcolor(&self) -> termcolor::StandardStream;
+
+    fn stdout(&mut self, out: &str);
+    fn stderr(&mut self, out: &str);
+
+    fn vars(&mut self) -> Vec<(String, String)>;
+    fn env_get(&mut self, key: OsString) -> Option<OsString>;
+    fn env_set(&mut self, k: OsString, v: OsString);
+    fn env_rm(&mut self, k: OsString);
+
+    fn width(&self) -> usize;
+}
+
+impl Host for Box<dyn Host> {
+    fn out_terminal(&self) -> Option<Box<term::StdoutTerminal>> {
+        (**self).out_terminal()
+    }
+
+    fn err_terminal(&self) -> Option<Box<term::StderrTerminal>> {
+        (**self).err_terminal()
+    }
+
+    fn stdout(&mut self, out: &str) {
+        (**self).stdout(out)
+    }
+
+    fn stderr(&mut self, out: &str) {
+        (**self).stderr(out)
+    }
+
+    fn vars(&mut self) -> Vec<(String, String)> {
+        (**self).vars()
+    }
+
+    fn env_get(&mut self, key: OsString) -> Option<OsString> {
+        (**self).env_get(key)
+    }
+
+    fn env_set(&mut self, key: OsString, value: OsString) {
+        (**self).env_set(key, value);
+    }
+
+    fn env_rm(&mut self, key: OsString) {
+        (**self).env_rm(key)
+    }
+
+    fn out_termcolor(&self) -> termcolor::StandardStream {
+        (**self).out_termcolor()
+    }
+
+    fn err_termcolor(&self) -> termcolor::StandardStream {
+        (**self).err_termcolor()
+    }
+
+    fn width(&self) -> usize {
+        (**self).width()
+    }
+}
+
+#[derive(Debug)]
+pub struct BasicHost;
+
+impl Host for BasicHost {
+    fn out_terminal(&self) -> Option<Box<term::StdoutTerminal>> {
+        term::stdout()
+    }
+
+    fn err_terminal(&self) -> Option<Box<term::StderrTerminal>> {
+        term::stderr()
+    }
+
+    fn stdout(&mut self, out: &str) {
+        match out {
+            "\n" => outln!(""),
+            other => outln!("{}", other),
+        }
+    }
+
+    fn stderr(&mut self, out: &str) {
+        match out {
+            "\n" => errln!(""),
+            other => errln!("{}", other),
+        }
+    }
+
+    fn vars(&mut self) -> Vec<(String, String)> {
+        std::env::vars().collect::<Vec<_>>()
+    }
+
+    fn env_get(&mut self, key: OsString) -> Option<OsString> {
+        std::env::var_os(key)
+    }
+
+    fn env_set(&mut self, key: OsString, value: OsString) {
+        std::env::set_var(key, value);
+    }
+
+    fn env_rm(&mut self, key: OsString) {
+        std::env::remove_var(key);
+    }
+
+    fn out_termcolor(&self) -> termcolor::StandardStream {
+        termcolor::StandardStream::stdout(termcolor::ColorChoice::Auto)
+    }
+
+    fn err_termcolor(&self) -> termcolor::StandardStream {
+        termcolor::StandardStream::stderr(termcolor::ColorChoice::Auto)
+    }
+
+    fn width(&self) -> usize {
+        std::cmp::max(textwrap::termwidth(), 20)
+    }
+}
+
+#[cfg(test)]
+#[derive(Debug)]
+pub struct FakeHost {
+    line_written: String,
+    env_vars: IndexMap<String, String>,
+}
+
+#[cfg(test)]
+impl FakeHost {
+    pub fn new() -> FakeHost {
+        FakeHost {
+            line_written: String::from(""),
+            env_vars: IndexMap::default(),
+        }
+    }
+}
+
+#[cfg(test)]
+impl Host for FakeHost {
+    fn out_terminal(&self) -> Option<Box<term::StdoutTerminal>> {
+        None
+    }
+
+    fn err_terminal(&self) -> Option<Box<term::StderrTerminal>> {
+        None
+    }
+
+    fn stdout(&mut self, out: &str) {
+        self.line_written = out.to_string();
+    }
+
+    fn stderr(&mut self, out: &str) {
+        self.line_written = out.to_string();
+    }
+
+    fn vars(&mut self) -> Vec<(String, String)> {
+        self.env_vars
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect::<Vec<_>>()
+    }
+
+    fn env_get(&mut self, key: OsString) -> Option<OsString> {
+        let key = key.into_string().expect("Couldn't convert to string.");
+
+        match self.env_vars.get(&key) {
+            Some(env) => Some(OsString::from(env)),
+            None => None,
+        }
+    }
+
+    fn env_set(&mut self, key: OsString, value: OsString) {
+        self.env_vars.insert(
+            key.into_string().expect("Couldn't convert to string."),
+            value.into_string().expect("Couldn't convert to string."),
+        );
+    }
+
+    fn env_rm(&mut self, key: OsString) {
+        self.env_vars
+            .shift_remove(&key.into_string().expect("Couldn't convert to string."));
+    }
+
+    fn out_termcolor(&self) -> termcolor::StandardStream {
+        termcolor::StandardStream::stdout(termcolor::ColorChoice::Auto)
+    }
+
+    fn err_termcolor(&self) -> termcolor::StandardStream {
+        termcolor::StandardStream::stderr(termcolor::ColorChoice::Auto)
+    }
+
+    fn width(&self) -> usize {
+        1
+    }
+}
+
+pub(crate) fn handle_unexpected<T>(
+    host: &mut dyn Host,
+    func: impl FnOnce(&mut dyn Host) -> Result<T, ShellError>,
+) {
+    let result = func(host);
+
+    if let Err(err) = result {
+        host.stderr(&format!("Something unexpected happened:\n{:?}", err));
+    }
+}