rjango 0.1.1

use std::io::{self, Write};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DeprecationWarning {
    pub message: String,
    pub version: String,
}

impl DeprecationWarning {
    #[must_use]
    pub fn new(message: &str, version: &str) -> Self {
        Self {
            message: message.to_string(),
            version: version.to_string(),
        }
    }

    #[must_use]
    pub fn render(&self) -> String {
        format!(
            "DeprecationWarning: {} (will be removed in {})",
            self.message, self.version
        )
    }
}

pub fn warn_deprecated(message: &str, removal_version: &str) {
    let mut stderr = io::stderr().lock();
    let _ = warn_deprecated_to(&mut stderr, message, removal_version);
}

pub fn warn_deprecated_to<W: Write>(
    writer: &mut W,
    message: &str,
    removal_version: &str,
) -> io::Result<()> {
    writeln!(
        writer,
        "{}",
        DeprecationWarning::new(message, removal_version).render()
    )
}

#[cfg(test)]
mod tests {
    use super::{DeprecationWarning, warn_deprecated_to};

    #[test]
    fn deprecation_warning_stores_message_and_version() {
        let warning = DeprecationWarning::new("legacy helper", "2.0");

        assert_eq!(warning.message, "legacy helper");
        assert_eq!(warning.version, "2.0");
    }

    #[test]
    fn deprecation_warning_renders_expected_message() {
        let warning = DeprecationWarning::new("legacy helper", "2.0");
        assert_eq!(
            warning.render(),
            "DeprecationWarning: legacy helper (will be removed in 2.0)"
        );
    }

    #[test]
    fn warn_deprecated_to_writes_to_provided_writer() {
        let mut output = Vec::new();
        warn_deprecated_to(&mut output, "legacy helper", "2.0").expect("warning should write");

        assert_eq!(
            String::from_utf8(output).expect("warning should be utf-8"),
            "DeprecationWarning: legacy helper (will be removed in 2.0)\n"
        );
    }
}