multi-ssh/src/environment.rs

use crate::shell_interface::{
  build_command_from_shell_command, CommandOutput, CommandResult, ExitStatus, ShellCommand,
  ShellInterface, StartError,
};
use std::env::VarError;
use std::ffi::{OsStr, OsString};
use std::path::PathBuf;
use std::{env, io};

pub trait Environment {
  fn args_os(&self) -> Vec<OsString>;
  fn var_os<K>(&self, key: K) -> Option<OsString>
  where
    K: AsRef<OsStr>;
  fn var<K>(&self, key: K) -> Result<String, VarError>
  where
    K: AsRef<OsStr>,
  {
    self
      .var_os(key)
      .ok_or(VarError::NotPresent)
      .and_then(|s| s.into_string().map_err(VarError::NotUnicode))
  }
  fn set_var<K, V>(&mut self, key: K, value: V)
  where
    K: AsRef<OsStr>,
    V: AsRef<OsStr>;
  fn get_home_directory(&self) -> Option<PathBuf>;
  fn read_line(&mut self) -> Result<String, io::Error>;
  fn is_ssh_agent_started(&self) -> bool;
  fn set_ssh_agent_started(&mut self, enabled: bool);
}

#[derive(Debug, Default)]
pub struct Prod {
  ssh_agent_started: bool,
}

impl Environment for Prod {
  fn args_os(&self) -> Vec<OsString> {
    env::args_os().collect()
  }

  fn var_os<K>(&self, key: K) -> Option<OsString>
  where
    K: AsRef<OsStr>,
  {
    env::var_os(key)
  }

  fn var<K>(&self, key: K) -> Result<String, VarError>
  where
    K: AsRef<OsStr>,
  {
    env::var(key)
  }

  fn set_var<K, V>(&mut self, key: K, value: V)
  where
    K: AsRef<OsStr>,
    V: AsRef<OsStr>,
  {
    env::set_var(key, value);
  }

  fn get_home_directory(&self) -> Option<PathBuf> {
    homedir::my_home().ok().flatten()
  }

  fn read_line(&mut self) -> Result<String, io::Error> {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer)?;
    Ok(buffer.trim().to_string())
  }

  fn is_ssh_agent_started(&self) -> bool {
    self.ssh_agent_started
  }

  fn set_ssh_agent_started(&mut self, enabled: bool) {
    self.ssh_agent_started = enabled;
  }
}

impl ShellInterface for Prod {
  fn run_command(&mut self, command: ShellCommand) -> CommandResult<ExitStatus, StartError> {
    CommandResult {
      result: build_command_from_shell_command(&command)
        .status()
        .map(ExitStatus::from)
        .map_err(StartError::from),
      command,
    }
  }

  fn collect_command_output(
    &mut self,
    command: ShellCommand,
  ) -> CommandResult<CommandOutput, StartError> {
    CommandResult {
      result: build_command_from_shell_command(&command)
        .output()
        .map(CommandOutput::from)
        .map_err(StartError::from),
      command,
    }
  }
}