heroku_rs 0.6.0

Rust bindings for the Heroku API
Documentation 
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

use std::error::Error;
use std::fmt;
use std::fmt::Debug;

/// HerokuApiError
///
/// Failing responses will have an appropriate status and a JSON body containing more details about a particular error. See error responses for more example ids.
///
/// [See the Heroku docs for this error struct](https://devcenter.heroku.com/articles/platform-api-reference#error-attributes)
#[derive(Deserialize, Debug, Default)]
pub struct HerokuApiError {
    /// end user message of error raised
    pub message: String,
    /// id of error raised
    pub id: String,
}

/// An enum to classify which errors are what.
#[derive(Debug)]
pub enum HerokuApiFailure {
    /// If Heroku API returned a Error code, this enum is used to handle the error
    Error(reqwest::StatusCode, HerokuApiError),
    /// If there was a invalid response, or the response failed, this enum is used to handle the error
    Invalid(reqwest::Error),
}

impl PartialEq for HerokuApiError {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id && self.message == other.message
    }
}

impl Error for HerokuApiFailure {}
impl Error for HerokuApiError {}

impl Eq for HerokuApiFailure {}
impl Eq for HerokuApiError {}

impl PartialEq for HerokuApiFailure {
    fn eq(&self, other: &HerokuApiFailure) -> bool {
        match (self, other) {
            (HerokuApiFailure::Invalid(e1), HerokuApiFailure::Invalid(e2)) => {
                e1.to_string() == e2.to_string()
            }
            (HerokuApiFailure::Error(status1, e1), HerokuApiFailure::Error(status2, e2)) => {
                status1 == status2 && e1 == e2
            }
            _ => false,
        }
    }
}

impl fmt::Display for HerokuApiError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error {} {} ", self.id, self.message)
    }
}

impl From<reqwest::Error> for HerokuApiFailure {
    fn from(error: reqwest::Error) -> Self {
        HerokuApiFailure::Invalid(error)
    }
}

impl fmt::Display for HerokuApiFailure {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            HerokuApiFailure::Error(status, error) => {
                let mut output = "".to_owned();
                output.push_str(&format!("HTTP: {}", status));

                output.push_str(&format!("\n{} {} ", error.id, error.message));
                write!(f, "{}", output)
            }
            HerokuApiFailure::Invalid(err) => write!(f, "{}", err),
        }
    }
}