rutie 0.10.2

use crate::{binding::vm, util, AnyObject, Array, Class, Object, RString};

/// Descendants of class Exception are used to communicate between Kernel#raise
/// and rescue statements in `begin ... end` blocks. Exception objects carry
/// information about the exception – its type (the exception's class name), an
/// optional descriptive string, and optional traceback information. Exception
/// subclasses may add additional information like NameError#name.
///
/// Programs may make subclasses of Exception, typically of StandardError or
/// RuntimeError, to provide custom classes and add additional information.
/// See the subclass list below for defaults for `raise` and `rescue`.
pub trait Exception: Object {
    /// Construct a new Exception object, optionally passing in a message.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM};
    /// # VM::init();
    ///
    /// assert_eq!(
    ///   AnyException::new("StandardError", None).to_s(),
    ///   "StandardError"
    /// );
    /// ```
    ///
    /// A nested exception
    ///
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM, Class};
    /// # VM::init();
    ///
    /// let mut klass = Class::new("MyGem", None);
    /// let se = Class::from_existing("StandardError");
    /// let _ = klass.define_nested_class("MyError", Some(&se));
    ///
    /// assert_eq!(
    ///   AnyException::new("MyGem::MyError", None).to_s(),
    ///   "MyGem::MyError"
    /// );
    /// ```
    fn new(class: &str, msg: Option<&str>) -> Self {
        let class = util::inmost_rb_object(class);
        let msg = msg.map(|s| RString::new_utf8(s).value());

        Self::from(vm::call_method(class, "new", util::option_to_slice(&msg)))
    }

    /// With no argument, or if the argument is the same as the receiver,
    /// return the receiver. Otherwise, create a new exception object of
    /// the same class as the receiver, but with a message equal
    /// to `string.to_str`.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM};
    /// # VM::init();
    ///
    /// assert_eq!(
    ///   AnyException::new("StandardError", Some("something went wrong")).exception(None),
    ///   AnyException::new("StandardError", Some("something went wrong"))
    /// );
    /// ```
    fn exception(&self, string: Option<&str>) -> Self {
        let string = string.map(|s| RString::new_utf8(s).value());

        Self::from(vm::call_method(
            self.value(),
            "exception",
            util::option_to_slice(&string),
        ))
    }

    /// Returns any backtrace associated with the exception. The
    /// backtrace is an array of strings, each containing either
    /// “filename:lineNo: in `method''' or “filename:lineNo.''
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM, RString};
    /// # VM::init();
    ///
    /// let x = AnyException::new("StandardError", Some("something went wrong"));
    ///
    /// assert!(x.backtrace().is_none());
    /// ```
    fn backtrace(&self) -> Option<Array> {
        let result = vm::call_method(self.value(), "backtrace", &[]);

        if result.is_nil() {
            return None;
        }

        Some(Array::from(result))
    }

    /// Returns any backtrace associated with the exception. This
    /// method is similar to #backtrace, but the backtrace is an
    /// array of Thread::Backtrace::Location.
    ///
    /// Now, this method is not affected by #set_backtrace.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM, RString};
    /// # VM::init();
    ///
    /// let x = AnyException::new("StandardError", Some("something went wrong"));
    ///
    /// assert!(x.backtrace_locations().is_none());
    /// ```
    fn backtrace_locations(&self) -> Option<Array> {
        let result = vm::call_method(self.value(), "backtrace_locations", &[]);

        if result.is_nil() {
            return None;
        }

        Some(Array::from(result))
    }

    /// Returns the previous exception at the time this
    /// exception was raised. This is useful for wrapping exceptions
    /// and retaining the original exception information.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM, RString};
    /// # VM::init();
    ///
    /// let x = AnyException::new("StandardError", Some("something went wrong"));
    ///
    /// assert!(x.cause().is_none());
    /// ```
    fn cause(&self) -> Option<Self> {
        let result = vm::call_method(self.value(), "cause", &[]);

        if result.is_nil() {
            return None;
        }

        Some(Self::from(result))
    }

    /// Return this exception's class name and message
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM};
    /// # VM::init();
    ///
    /// assert_eq!(
    ///   AnyException::new("StandardError", Some("oops")).inspect(),
    ///   "#<StandardError: oops>"
    /// );
    /// ```
    fn inspect(&self) -> String {
        RString::from(vm::call_method(self.value(), "inspect", &[])).to_string()
    }

    /// Returns the result of invoking `exception.to_s`. Normally this
    /// returns the exception's message or name.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM};
    /// # VM::init();
    ///
    /// assert_eq!(
    ///   AnyException::new("StandardError", Some("oops")).message(),
    ///   "oops"
    /// );
    /// ```
    fn message(&self) -> String {
        RString::from(vm::call_method(self.value(), "message", &[])).to_string()
    }

    /// Sets the backtrace information associated with exc. The backtrace
    /// must be an array of String objects or a single String in the format
    /// described in #backtrace.
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM, RString, Array};
    /// # VM::init();
    ///
    /// let x = AnyException::new("StandardError", Some("something went wrong"));
    ///
    /// let mut arr = Array::new();
    /// arr.push(RString::new_utf8("prog.rb:10"));
    ///
    /// x.set_backtrace(arr.to_any_object());
    ///
    /// assert_eq!(
    ///   x.backtrace().
    ///     unwrap().
    ///     pop().
    ///     try_convert_to::<RString>().
    ///     unwrap().
    ///     to_string(),
    ///   "prog.rb:10"
    /// );
    /// ```
    fn set_backtrace(&self, backtrace: AnyObject) -> Option<Array> {
        let result = vm::call_method(self.value(), "set_backtrace", &[backtrace.value()]);

        if result.is_nil() {
            return None;
        }

        Some(Array::from(result))
    }

    /// Returns exception's message (or the name of the exception if no message is set).
    ///
    /// # Examples
    /// ```
    /// use rutie::{AnyException, Exception, Object, VM};
    /// # VM::init();
    ///
    /// assert_eq!(
    ///   AnyException::new("StandardError", Some("oops")).to_s(),
    ///   "oops"
    /// );
    /// ```
    fn to_s(&self) -> String {
        RString::from(vm::call_method(self.value(), "to_s", &[])).to_string()
    }
}

#[cfg(test)]
mod tests {
    use crate::{AnyException, AnyObject, Array, Class, Exception, Object, RString, VM};

    #[test]
    fn test_exception_trait() {
        crate::on_ruby_thread(|| {
            let error = AnyException::new("ArgumentError", Some("bad value"));
            assert_eq!(error.message(), "bad value");
            assert_eq!(error.to_s(), "bad value");
            assert_eq!(error.inspect(), "#<ArgumentError: bad value>");
            assert!(Class::argument_error().case_equals(&error));

            // `exception` copies with a new message; without one it is the same object.
            let copy = error.exception(Some("other"));
            assert_eq!(copy.message(), "other");
            assert_eq!(error.message(), "bad value");
            assert!(error.exception(None).equals(&error));

            // Not raised yet, so no backtrace.
            assert!(error.backtrace().is_none());
            assert!(error.backtrace_locations().is_none());

            let mut trace = Array::new();
            trace.push(RString::new_utf8("file.rb:1"));
            let set = error.set_backtrace(trace.to_any_object()).unwrap();
            assert_eq!(set.length(), 1);
            assert_eq!(
                error
                    .backtrace()
                    .unwrap()
                    .at(0)
                    .try_convert_to::<RString>()
                    .unwrap()
                    .to_str(),
                "file.rb:1"
            );

            let raised = VM::eval(
                "begin
                   begin
                     raise 'inner'
                   rescue
                     raise ArgumentError, 'outer'
                   end
                 rescue => e
                   e
                 end",
            )
            .unwrap()
            .try_convert_to::<AnyException>()
            .unwrap();
            assert_eq!(raised.cause().unwrap().message(), "inner");
            assert!(raised.cause().unwrap().cause().is_none());
            assert!(raised.backtrace().unwrap().length() > 0);
            assert!(raised.backtrace_locations().unwrap().length() > 0);

            let any: AnyObject = raised.to_any_object();
            assert!(any.try_convert_to::<AnyException>().is_ok());
        });
    }
}