code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/magnus-0.8.2/src/time.rs

@@ -0,0 +1,462 @@
+//! Types and functions for working with Ruby's Time class.
+//!
+//! See also [`Ruby`](Ruby#time) for more Time related methods.
+
+use std::{
+    fmt,
+    os::raw::c_int,
+    time::{Duration, SystemTime},
+};
+
+use rb_sys::{
+    rb_time_nano_new, rb_time_new, rb_time_timespec, rb_time_timespec_new, rb_time_utc_offset,
+    timespec, VALUE,
+};
+
+use crate::{
+    api::Ruby,
+    error::{protect, Error, IntoError},
+    into_value::IntoValue,
+    object::Object,
+    r_typed_data::RTypedData,
+    try_convert::TryConvert,
+    value::{
+        private::{self, ReprValue as _},
+        Fixnum, ReprValue, Value,
+    },
+};
+
+/// # `Time`
+///
+/// Functions to create and work with Ruby `Time` objects.
+///
+/// See also the [`Time`] type.
+impl Ruby {
+    /// Create a new `Time` in the local timezone.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{rb_assert, Error, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let t = ruby.time_new(1654013280, 0)?;
+    ///
+    ///     rb_assert!(ruby, r#"t == Time.new(2022, 5, 31, 9, 8, 0, "-07:00")"#, t);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn time_new(&self, seconds: i64, microseconds: i64) -> Result<Time, Error> {
+        protect(|| unsafe {
+            Time::from_rb_value_unchecked(rb_time_new(
+                seconds.try_into().unwrap(),
+                microseconds.try_into().unwrap(),
+            ))
+        })
+    }
+
+    /// Create a new `Time` with nanosecond resolution in the local timezone.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{rb_assert, Error, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let t = ruby.time_nano_new(1654013280, 0)?;
+    ///
+    ///     rb_assert!(ruby, r#"t == Time.new(2022, 5, 31, 9, 8, 0, "-07:00")"#, t);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn time_nano_new(&self, seconds: i64, nanoseconds: i64) -> Result<Time, Error> {
+        protect(|| unsafe {
+            Time::from_rb_value_unchecked(rb_time_nano_new(
+                seconds.try_into().unwrap(),
+                nanoseconds.try_into().unwrap(),
+            ))
+        })
+    }
+
+    /// Create a new `Time` with nanosecond resolution with the given offset.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{
+    ///     error::IntoError,
+    ///     rb_assert,
+    ///     time::{Offset, Timespec},
+    ///     Error, Ruby,
+    /// };
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let ts = Timespec {
+    ///         tv_sec: 1654013280,
+    ///         tv_nsec: 0,
+    ///     };
+    ///     let offset = Offset::from_hours(-7).map_err(|e| e.into_error(ruby))?;
+    ///     let t = ruby.time_timespec_new(ts, offset)?;
+    ///
+    ///     rb_assert!(ruby, r#"t == Time.new(2022, 5, 31, 9, 8, 0, "-07:00")"#, t);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn time_timespec_new(&self, ts: Timespec, offset: Offset) -> Result<Time, Error> {
+        protect(|| unsafe {
+            Time::from_rb_value_unchecked(rb_time_timespec_new(
+                &ts.into() as *const _,
+                offset.as_c_int(),
+            ))
+        })
+    }
+}
+
+/// Struct representing a point in time as an offset from the UNIX epoch.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Timespec {
+    /// Seconds since the UNIX epoch.
+    pub tv_sec: i64,
+    /// Subsecond offset in nanoseconds.
+    pub tv_nsec: i64,
+}
+
+impl From<timespec> for Timespec {
+    fn from(val: timespec) -> Self {
+        Self {
+            tv_sec: val.tv_sec as _,
+            tv_nsec: val.tv_nsec as _,
+        }
+    }
+}
+
+impl From<Timespec> for timespec {
+    fn from(val: Timespec) -> Self {
+        Self {
+            tv_sec: val.tv_sec as _,
+            tv_nsec: val.tv_nsec as _,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum OffsetType {
+    Local,
+    UTC,
+    Offset(c_int),
+}
+
+/// Struct representing an offset from UTC.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Offset(OffsetType);
+
+impl Offset {
+    /// Creates a new `Offset` from the specified number of seconds.
+    pub fn from_secs(offset: i32) -> Result<Self, OffsetError> {
+        match offset {
+            -86400..=86400 => Ok(Self(OffsetType::Offset(offset as _))),
+            _ => Err(OffsetError(offset)),
+        }
+    }
+
+    /// Creates a new `Offset` from the specified number of minutes.
+    pub fn from_mins(offset: i32) -> Result<Self, OffsetError> {
+        Self::from_secs(offset * 60)
+    }
+
+    /// Creates a new `Offset` from the specified number of hours.
+    pub fn from_hours(offset: i32) -> Result<Self, OffsetError> {
+        Self::from_secs(offset * 60)
+    }
+
+    /// Create a new `Offset` representing local time.
+    pub fn local() -> Self {
+        Self(OffsetType::Local)
+    }
+
+    /// Create a new `Offset` representing UTC.
+    pub fn utc() -> Self {
+        Self(OffsetType::UTC)
+    }
+
+    fn as_c_int(&self) -> c_int {
+        match self.0 {
+            OffsetType::Local => c_int::MAX,
+            OffsetType::UTC => c_int::MAX - 1,
+            OffsetType::Offset(i) => i,
+        }
+    }
+}
+
+/// An error returned when an [`Offset`] is out of range.
+#[derive(Debug)]
+pub struct OffsetError(i32);
+
+impl fmt::Display for OffsetError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "utc_offset {} out of range (-86400 to 86400)", self.0)
+    }
+}
+
+impl std::error::Error for OffsetError {}
+
+impl IntoError for OffsetError {
+    #[inline]
+    fn into_error(self, ruby: &Ruby) -> Error {
+        Error::new(ruby.exception_arg_error(), self.to_string())
+    }
+}
+
+/// Wrapper type for a Value known to be an instance of Ruby's Time class.
+///
+/// See the [`ReprValue`] and [`Object`] traits for additional methods
+/// available on this type. See [`Ruby`](Ruby#time) for methods to create a
+/// `Time`.
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct Time(RTypedData);
+
+impl Time {
+    /// Return `Some(Time)` if `val` is a `Time`, `None` otherwise.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::eval;
+    /// # let _cleanup = unsafe { magnus::embed::init() };
+    ///
+    /// assert!(magnus::Time::from_value(eval("Time.now").unwrap()).is_some());
+    /// assert!(magnus::Time::from_value(eval("0").unwrap()).is_none());
+    /// ```
+    #[inline]
+    pub fn from_value(val: Value) -> Option<Self> {
+        RTypedData::from_value(val)
+            .filter(|_| val.is_kind_of(Ruby::get_with(val).class_time()))
+            .map(Self)
+    }
+
+    #[inline]
+    pub(crate) unsafe fn from_rb_value_unchecked(val: VALUE) -> Self {
+        Self(RTypedData::from_rb_value_unchecked(val))
+    }
+
+    /// Returns the timezone offset of `self` from UTC in seconds.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{Error, Ruby, Time};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let t: Time = ruby.eval(r#"Time.new(2022, 5, 31, 9, 8, 0, "-07:00")"#)?;
+    ///
+    ///     assert_eq!(t.utc_offset(), -25_200);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn utc_offset(self) -> i64 {
+        unsafe { Fixnum::from_rb_value_unchecked(rb_time_utc_offset(self.as_rb_value())).to_i64() }
+    }
+
+    /// Returns `self` as a [`Timespec`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{Error, Ruby, Time};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let t: Time =
+    ///         ruby.eval(r#"Time.new(2022, 5, 31, 9, 8, 123456789/1000000000r, "-07:00")"#)?;
+    ///
+    ///     assert_eq!(t.timespec()?.tv_sec, 1654013280);
+    ///     assert_eq!(t.timespec()?.tv_nsec, 123456789);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn timespec(self) -> Result<Timespec, Error> {
+        let mut timespec = timespec {
+            tv_sec: 0,
+            tv_nsec: 0,
+        };
+        protect(|| unsafe {
+            timespec = rb_time_timespec(self.as_rb_value());
+            Ruby::get_unchecked().qnil()
+        })?;
+        Ok(timespec.into())
+    }
+}
+
+impl fmt::Display for Time {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", unsafe { self.to_s_infallible() })
+    }
+}
+
+impl fmt::Debug for Time {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.inspect())
+    }
+}
+
+impl IntoValue for Time {
+    #[inline]
+    fn into_value_with(self, _: &Ruby) -> Value {
+        self.0.as_value()
+    }
+}
+
+impl IntoValue for SystemTime {
+    #[inline]
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        match self.duration_since(Self::UNIX_EPOCH) {
+            Ok(duration) => ruby
+                .time_nano_new(
+                    duration.as_secs().try_into().unwrap(),
+                    duration.subsec_nanos().into(),
+                )
+                .unwrap()
+                .as_value(),
+            Err(_) => {
+                let duration = Self::UNIX_EPOCH.duration_since(self).unwrap();
+                ruby.time_nano_new(
+                    -i64::try_from(duration.as_secs()).unwrap(),
+                    -i64::from(duration.subsec_nanos()),
+                )
+                .unwrap()
+                .as_value()
+            }
+        }
+    }
+}
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+impl IntoValue for chrono::DateTime<chrono::Utc> {
+    #[inline]
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let delta = self.signed_duration_since(Self::UNIX_EPOCH);
+        let ts = Timespec {
+            tv_sec: delta.num_seconds(),
+            tv_nsec: delta.subsec_nanos() as _,
+        };
+        ruby.time_timespec_new(ts, Offset::utc())
+            .unwrap()
+            .as_value()
+    }
+}
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+impl IntoValue for chrono::DateTime<chrono::FixedOffset> {
+    #[inline]
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        use chrono::{DateTime, FixedOffset, Utc};
+        let delta = self.signed_duration_since(DateTime::<Utc>::UNIX_EPOCH);
+        let ts = Timespec {
+            tv_sec: delta.num_seconds(),
+            tv_nsec: delta.subsec_nanos() as _,
+        };
+        let offset: FixedOffset = self.timezone();
+        let offset = Offset::from_secs(offset.local_minus_utc()).unwrap();
+        ruby.time_timespec_new(ts, offset).unwrap().as_value()
+    }
+}
+
+impl Object for Time {}
+
+unsafe impl private::ReprValue for Time {}
+
+impl ReprValue for Time {}
+
+impl TryConvert for Time {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        Self::from_value(val).ok_or_else(|| {
+            Error::new(
+                Ruby::get_with(val).exception_type_error(),
+                format!("no implicit conversion of {} into Time", unsafe {
+                    val.classname()
+                },),
+            )
+        })
+    }
+}
+
+impl TryConvert for SystemTime {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let mut timespec = timespec {
+            tv_sec: 0,
+            tv_nsec: 0,
+        };
+        protect(|| unsafe {
+            timespec = rb_time_timespec(val.as_rb_value());
+            Ruby::get_unchecked().qnil()
+        })?;
+        if timespec.tv_nsec >= 0 {
+            let mut duration = Duration::from_secs(timespec.tv_sec.unsigned_abs() as _);
+            duration += Duration::from_nanos(timespec.tv_nsec as _);
+            if timespec.tv_sec >= 0 {
+                Ok(Self::UNIX_EPOCH + duration)
+            } else {
+                Ok(Self::UNIX_EPOCH - duration)
+            }
+        } else {
+            Err(Error::new(
+                Ruby::get_with(val).exception_arg_error(),
+                "time nanos must not be negative",
+            ))
+        }
+    }
+}
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+impl TryConvert for chrono::DateTime<chrono::Utc> {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let mut timespec = timespec {
+            tv_sec: 0,
+            tv_nsec: 0,
+        };
+        protect(|| unsafe {
+            timespec = rb_time_timespec(val.as_rb_value());
+            Ruby::get_unchecked().qnil()
+        })?;
+        match chrono::Duration::new(timespec.tv_sec as _, timespec.tv_nsec as _) {
+            Some(duration) => Ok(Self::UNIX_EPOCH + duration),
+            None => Err(Error::new(
+                Ruby::get_with(val).exception_arg_error(),
+                "time out of range",
+            )),
+        }
+    }
+}
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+impl TryConvert for chrono::DateTime<chrono::FixedOffset> {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        use chrono::{DateTime, FixedOffset, Utc};
+        let offset: i32 = val.funcall("utc_offset", ())?;
+        let dt: DateTime<Utc> = TryConvert::try_convert(val)?;
+        let tz = match FixedOffset::east_opt(offset) {
+            Some(tz) => tz,
+            None => {
+                return Err(Error::new(
+                    Ruby::get_with(val).exception_arg_error(),
+                    "invalid UTC offset",
+                ))
+            }
+        };
+        Ok(dt.with_timezone(&tz))
+    }
+}

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/src/try_convert.rs

@@ -26,7 +26,7 @@ pub trait TryConvert: Sized {
 /// Conversions from [`Value`] to Rust types that do not contain [`Value`].
 ///
 /// This trait is used as a bound on some implementations of [`TryConvert`]
-/// (for example, for [`Vec`]) to prevent heap allocated datastructures
+/// (for example, for [`Vec`]) to prevent heap allocated data structures
 /// containing `Value`, as it is not safe to store a `Value` on the heap.
 ///
 /// # Safety
@@ -86,6 +86,14 @@ impl TryConvert for i64 {
 }
 unsafe impl TryConvertOwned for i64 {}
 
+impl TryConvert for i128 {
+    #[inline]
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        Integer::try_convert(val)?.to_i128()
+    }
+}
+unsafe impl TryConvertOwned for i128 {}
+
 impl TryConvert for isize {
     #[inline]
     fn try_convert(val: Value) -> Result<Self, Error> {
@@ -126,6 +134,14 @@ impl TryConvert for u64 {
 }
 unsafe impl TryConvertOwned for u64 {}
 
+impl TryConvert for u128 {
+    #[inline]
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        Integer::try_convert(val)?.to_u128()
+    }
+}
+unsafe impl TryConvertOwned for u128 {}
+
 impl TryConvert for usize {
     #[inline]
     fn try_convert(val: Value) -> Result<Self, Error> {
@@ -134,6 +150,34 @@ impl TryConvert for usize {
 }
 unsafe impl TryConvertOwned for usize {}
 
+macro_rules! impl_non_zero_try_convert {
+    ($type:ty, $prim:ty) => {
+        impl TryConvert for $type {
+            #[inline]
+            fn try_convert(val: Value) -> Result<Self, Error> {
+                <$type>::new(<$prim>::try_convert(val)?).ok_or(Error::new(
+                    Ruby::get_with(val).exception_arg_error(),
+                    "value must be non-zero",
+                ))
+            }
+        }
+        unsafe impl TryConvertOwned for $type {}
+    };
+}
+
+impl_non_zero_try_convert!(std::num::NonZeroI8, i8);
+impl_non_zero_try_convert!(std::num::NonZeroI16, i16);
+impl_non_zero_try_convert!(std::num::NonZeroI32, i32);
+impl_non_zero_try_convert!(std::num::NonZeroI64, i64);
+impl_non_zero_try_convert!(std::num::NonZeroI128, i128);
+impl_non_zero_try_convert!(std::num::NonZeroIsize, isize);
+impl_non_zero_try_convert!(std::num::NonZeroU8, u8);
+impl_non_zero_try_convert!(std::num::NonZeroU16, u16);
+impl_non_zero_try_convert!(std::num::NonZeroU32, u32);
+impl_non_zero_try_convert!(std::num::NonZeroU64, u64);
+impl_non_zero_try_convert!(std::num::NonZeroU128, u128);
+impl_non_zero_try_convert!(std::num::NonZeroUsize, usize);
+
 impl TryConvert for f32 {
     #[inline]
     fn try_convert(val: Value) -> Result<Self, Error> {
@@ -240,7 +284,7 @@ macro_rules! impl_try_convert {
             }
             unsafe impl<#(T~N,)*> TryConvertOwned for (#(T~N,)*)
             where
-                #(T~N: TryConvert,)*
+                #(T~N: TryConvertOwned,)*
             {
             }
         });
@@ -269,6 +313,24 @@ where
 {
 }
 
+impl<K, V> TryConvert for std::collections::BTreeMap<K, V>
+where
+    K: TryConvertOwned + Eq + std::hash::Hash + Ord,
+    V: TryConvertOwned,
+{
+    #[inline]
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        debug_assert_value!(val);
+        RHash::try_convert(val)?.to_btree_map()
+    }
+}
+unsafe impl<K, V> TryConvertOwned for std::collections::BTreeMap<K, V>
+where
+    K: TryConvertOwned + Eq + std::hash::Hash + Ord,
+    V: TryConvertOwned,
+{
+}
+
 #[cfg(unix)]
 impl TryConvert for PathBuf {
     fn try_convert(val: Value) -> Result<Self, Error> {