1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

use self::super::util::uppercase_first;
use std::io::Write;


/// Enum representing all possible ways the application can fail.
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum Error {
    /// The specified file would need to be overriden but was not allowed to.
    OverrideNoForce(String),
    /// The specified subsystem needs to be run beforehand to produce the specified file.
    RequiredFileFromSubsystemNonexistant {
        /// The subsystem that needs to be run.
        subsys: &'static str,
        /// The file the specified subsystem produces.
        fname: String,
    },
    /// Failed to parse the specified file because of the specified errors.
    FileParsingFailed {
        /// The file that failed to parse.
        desc: &'static str,
        /// The parsing errors that occured.
        errors: Vec<String>,
    },
    /// An I/O error occured.
    ///
    /// This includes higher-level I/O errors like FS ones.
    Io {
        /// The file the I/O operation regards.
        desc: &'static str,
        /// The failed operation.
        ///
        /// This should be lowercase and imperative ("create", "open").
        op: &'static str,
    },
    /// A watched item does not exist.
    WatchedDoesNotExist {
        /// The type of nonexistant resource.
        tp: &'static str,
        /// The name of the nonexistant resource.
        name: String,
    },
    /// Failed to log in to the specified service.
    LoginFailed(&'static str),
}

impl Error {
    /// Write the error message to the specified output stream.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dishub::Error;
    /// # use std::iter::FromIterator;
    /// let mut out = Vec::new();
    /// Error::FileParsingFailed {
    ///     desc: "leaderboard",
    ///     errors: vec![],
    /// }.print_error(&mut out);
    /// assert_eq!(String::from_iter(out.iter().map(|&i| i as char)),
    ///            "Failed to parse leaderboard.\n".to_string());
    /// ```
    pub fn print_error<W: Write>(&self, err_out: &mut W) {
        match *self {
            Error::OverrideNoForce(ref fname) => {
                writeln!(err_out, "File \"{}\" was not overriden to prevent data loss.", fname).unwrap();
                writeln!(err_out, "Pass --force to override it.").unwrap();
            }
            Error::RequiredFileFromSubsystemNonexistant { subsys, ref fname } => {
                writeln!(err_out, "Run the {} subsystem first to produce \"{}\".", subsys, fname).unwrap()
            }
            Error::FileParsingFailed { desc, ref errors } => {
                writeln!(err_out, "Failed to parse {}{}", desc, if errors.is_empty() { '.' } else { ':' }).unwrap();
                for err in errors {
                    writeln!(err_out, "  {}", err).unwrap()
                }
            }
            Error::Io { desc, op } => {
                // Strip the last 'e', if any, so we get correct inflection for continuous times
                let op = uppercase_first(if op.ends_with('e') {
                    &op[..op.len() - 1]
                } else {
                    op
                });
                writeln!(err_out, "{}ing {} failed.", op, desc).unwrap()
            }
            Error::WatchedDoesNotExist { tp, ref name } => writeln!(err_out, "The watched {} \"{}\" doesn't exist.", tp, name).unwrap(),
            Error::LoginFailed(service) => writeln!(err_out, "Failed to log in to {}.", service).unwrap(),
        }
    }

    /// Get the executable exit value from an `Error` instance.
    ///
    /// # Examples
    ///
    /// ```
    /// # use dishub::Error;
    /// assert_eq!(Error::FileParsingFailed {
    ///     desc: "",
    ///     errors: vec![],
    /// }.exit_value(), 3);
    /// ```
    pub fn exit_value(&self) -> i32 {
        match *self {
            Error::OverrideNoForce(_) => 1,
            Error::RequiredFileFromSubsystemNonexistant { .. } => 2,
            Error::FileParsingFailed { .. } => 3,
            Error::Io { .. } => 4,
            Error::WatchedDoesNotExist { .. } => 5,
            Error::LoginFailed(_) => 6,
        }
    }
}