polars-df 0.21.0 → 0.22.0

data/ext/polars/src/catalog/unity.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use magnus::value::{Lazy, ReprValue};
-use magnus::{IntoValue, Module, RArray, RClass, RHash, RModule, Ruby, Value};
+use magnus::{IntoValue, Module, RClass, RHash, RModule, Ruby, Value};
 use polars::prelude::{PlHashMap, PlSmallStr, Schema};
 use polars_io::catalog::unity::client::{CatalogClient, CatalogClientBuilder};
 use polars_io::catalog::unity::models::{
@@ -85,15 +85,15 @@ impl RbCatalogClient {
         builder.build().map(RbCatalogClient).map_err(to_rb_err)
     }
 
-    pub fn list_catalogs(&self) -> RbResult<Value> {
+    pub fn list_catalogs(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_catalogs())
+            .block_in_place_on(rb_self.client().list_catalogs())
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|x| {
-            let v = catalog_info_to_rbobject(x);
+        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
+            let v = catalog_info_to_rbobject(ruby, x);
             if let Ok(v) = v {
                 Some(v)
             } else {
@@ -104,18 +104,18 @@ impl RbCatalogClient {
 
         opt_err.transpose()?;
 
-        Ok(out.into_value())
+        Ok(out.as_value())
     }
 
-    pub fn list_namespaces(&self, catalog_name: String) -> RbResult<Value> {
+    pub fn list_namespaces(ruby: &Ruby, rb_self: &Self, catalog_name: String) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_namespaces(&catalog_name))
+            .block_in_place_on(rb_self.client().list_namespaces(&catalog_name))
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|x| {
-            let v = namespace_info_to_rbobject(x);
+        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
+            let v = namespace_info_to_rbobject(ruby, x);
             match v {
                 Ok(v) => Some(v),
                 Err(_) => {
@@ -127,27 +127,33 @@ impl RbCatalogClient {
 
         opt_err.transpose()?;
 
-        Ok(out.into_value())
+        Ok(out.as_value())
     }
 
-    pub fn list_tables(&self, catalog_name: String, namespace: String) -> RbResult<Value> {
+    pub fn list_tables(
+        ruby: &Ruby,
+        rb_self: &Self,
+        catalog_name: String,
+        namespace: String,
+    ) -> RbResult<Value> {
         let v = pl_async::get_runtime()
-            .block_in_place_on(self.client().list_tables(&catalog_name, &namespace))
+            .block_in_place_on(rb_self.client().list_tables(&catalog_name, &namespace))
             .map_err(to_rb_err)?;
 
         let mut opt_err = None;
 
-        let out = RArray::from_iter(v.into_iter().map(|table_info| {
-            let v = table_info_to_rbobject(table_info);
+        let out = ruby
+            .ary_from_iter(v.into_iter().map(|table_info| {
+                let v = table_info_to_rbobject(ruby, table_info);
 
-            if let Ok(v) = v {
-                Some(v)
-            } else {
-                opt_err.replace(v);
-                None
-            }
-        }))
-        .into_value();
+                if let Ok(v) = v {
+                    Some(v)
+                } else {
+                    opt_err.replace(v);
+                    None
+                }
+            }))
+            .as_value();
 
         opt_err.transpose()?;
 
@@ -155,36 +161,39 @@ impl RbCatalogClient {
     }
 
     pub fn get_table_info(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         table_name: String,
         catalog_name: String,
         namespace: String,
     ) -> RbResult<Value> {
         let table_info = pl_async::get_runtime()
-            .block_in_place_on(
-                self.client()
-                    .get_table_info(&table_name, &catalog_name, &namespace),
-            )
+            .block_in_place_on(rb_self.client().get_table_info(
+                &table_name,
+                &catalog_name,
+                &namespace,
+            ))
             .map_err(to_rb_err)?;
 
-        table_info_to_rbobject(table_info)
+        table_info_to_rbobject(ruby, table_info)
     }
 
     pub fn create_catalog(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
         let catalog_info = pl_async::get_runtime()
-            .block_in_place_on(self.client().create_catalog(
+            .block_in_place_on(rb_self.client().create_catalog(
                 &catalog_name,
                 comment.as_deref(),
                 storage_root.as_deref(),
             ))
             .map_err(to_rb_err)?;
 
-        catalog_info_to_rbobject(catalog_info)
+        catalog_info_to_rbobject(ruby, catalog_info)
     }
 
     pub fn delete_catalog(&self, catalog_name: String, force: bool) -> RbResult<()> {
@@ -194,14 +203,15 @@ impl RbCatalogClient {
     }
 
     pub fn create_namespace(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         namespace: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
         let namespace_info = pl_async::get_runtime()
-            .block_in_place_on(self.client().create_namespace(
+            .block_in_place_on(rb_self.client().create_namespace(
                 &catalog_name,
                 &namespace,
                 comment.as_deref(),
@@ -209,7 +219,7 @@ impl RbCatalogClient {
             ))
             .map_err(to_rb_err)?;
 
-        namespace_info_to_rbobject(namespace_info)
+        namespace_info_to_rbobject(ruby, namespace_info)
     }
 
     pub fn delete_namespace(
@@ -228,7 +238,8 @@ impl RbCatalogClient {
 
     #[allow(clippy::too_many_arguments)]
     pub fn create_table(
-        &self,
+        ruby: &Ruby,
+        rb_self: &Self,
         catalog_name: String,
         namespace: String,
         table_name: String,
@@ -241,7 +252,7 @@ impl RbCatalogClient {
     ) -> RbResult<Value> {
         let table_info = pl_async::get_runtime()
             .block_in_place_on(
-                self.client().create_table(
+                rb_self.client().create_table(
                     &catalog_name,
                     &namespace,
                     &table_name,
@@ -261,7 +272,7 @@ impl RbCatalogClient {
             )
             .map_err(to_rb_err)?;
 
-        table_info_to_rbobject(table_info)
+        table_info_to_rbobject(ruby, table_info)
     }
 
     pub fn delete_table(
@@ -278,8 +289,8 @@ impl RbCatalogClient {
             .map_err(to_rb_err)
     }
 
-    pub fn type_json_to_polars_type(type_json: String) -> RbResult<Value> {
-        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value())
+    pub fn type_json_to_polars_type(ruby: &Ruby, type_json: String) -> RbResult<Value> {
+        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value_with(ruby))
     }
 }
 
@@ -290,6 +301,7 @@ impl RbCatalogClient {
 }
 
 fn catalog_info_to_rbobject(
+    ruby: &Ruby,
     CatalogInfo {
         name,
         comment,
@@ -302,10 +314,10 @@ fn catalog_info_to_rbobject(
         updated_by,
     }: CatalogInfo,
 ) -> RbResult<Value> {
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
-    let properties = properties_to_rbobject(properties);
-    let options = properties_to_rbobject(options);
+    let properties = properties_to_rbobject(ruby, properties);
+    let options = properties_to_rbobject(ruby, options);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -319,13 +331,11 @@ fn catalog_info_to_rbobject(
         updated_by
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&CATALOG_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&CATALOG_INFO_CLS).funcall("new", (dict,))
 }
 
 fn namespace_info_to_rbobject(
+    ruby: &Ruby,
     NamespaceInfo {
         name,
         comment,
@@ -337,9 +347,9 @@ fn namespace_info_to_rbobject(
         updated_by,
     }: NamespaceInfo,
 ) -> RbResult<Value> {
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
-    let properties = properties_to_rbobject(properties);
+    let properties = properties_to_rbobject(ruby, properties);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -352,13 +362,10 @@ fn namespace_info_to_rbobject(
         updated_by
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&NAMESPACE_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&NAMESPACE_INFO_CLS).funcall("new", (dict,))
 }
 
-fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
+fn table_info_to_rbobject(ruby: &Ruby, table_info: TableInfo) -> RbResult<Value> {
     let TableInfo {
         name,
         table_id,
@@ -374,49 +381,47 @@ fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
         updated_by,
     } = table_info;
 
-    let column_info_cls = Ruby::get().unwrap().get_inner(&COLUMN_INFO_CLS);
+    let column_info_cls = ruby.get_inner(&COLUMN_INFO_CLS);
 
     let columns = columns
         .map(|columns| {
-            Ruby::get()
-                .unwrap()
-                .ary_try_from_iter(columns.into_iter().map(
-                    |ColumnInfo {
-                         name,
-                         type_name,
-                         type_text,
-                         type_json,
-                         position,
-                         comment,
-                         partition_index,
-                     }| {
-                        let dict = RHash::new();
-
-                        let name = name.as_str();
-                        let type_name = type_name.as_str();
-                        let type_text = type_text.as_str();
-
-                        rbdict_insert_keys!(dict, {
-                            name,
-                            type_name,
-                            type_text,
-                            type_json,
-                            position,
-                            comment,
-                            partition_index,
-                        });
-
-                        column_info_cls.funcall::<_, _, Value>("new", (dict,))
-                    },
-                ))
+            ruby.ary_try_from_iter(columns.into_iter().map(
+                |ColumnInfo {
+                     name,
+                     type_name,
+                     type_text,
+                     type_json,
+                     position,
+                     comment,
+                     partition_index,
+                 }| {
+                    let dict = ruby.hash_new();
+
+                    let name = name.as_str();
+                    let type_name = type_name.as_str();
+                    let type_text = type_text.as_str();
+
+                    rbdict_insert_keys!(dict, {
+                        name,
+                        type_name,
+                        type_text,
+                        type_json,
+                        position,
+                        comment,
+                        partition_index,
+                    });
+
+                    column_info_cls.funcall::<_, _, Value>("new", (dict,))
+                },
+            ))
         })
         .transpose()?;
 
-    let dict = RHash::new();
+    let dict = ruby.hash_new();
 
     let data_source_format = data_source_format.map(|x| x.to_string());
     let table_type = table_type.to_string();
-    let properties = properties_to_rbobject(properties);
+    let properties = properties_to_rbobject(ruby, properties);
 
     rbdict_insert_keys!(dict, {
         name,
@@ -433,14 +438,11 @@ fn table_info_to_rbobject(table_info: TableInfo) -> RbResult<Value> {
         updated_by,
     });
 
-    Ruby::get()
-        .unwrap()
-        .get_inner(&TABLE_INFO_CLS)
-        .funcall("new", (dict,))
+    ruby.get_inner(&TABLE_INFO_CLS).funcall("new", (dict,))
 }
 
-fn properties_to_rbobject(properties: PlHashMap<PlSmallStr, String>) -> RHash {
-    let dict = RHash::new();
+fn properties_to_rbobject(ruby: &Ruby, properties: PlHashMap<PlSmallStr, String>) -> RHash {
+    let dict = ruby.hash_new();
 
     for (key, value) in properties.into_iter() {
         dict.aset(key.as_str(), value).unwrap();

data/ext/polars/src/conversion/any_value.rs

@@ -1,14 +1,15 @@
-use magnus::encoding::{EncodingCapable, Index};
+use magnus::encoding::EncodingCapable;
 use magnus::{
-    IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value, class, prelude::*, r_hash::ForEach,
+    IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value, prelude::*, r_hash::ForEach,
 };
 use polars::prelude::*;
 use polars_core::utils::any_values_to_supertype_and_n_dtypes;
 
+use super::datetime::datetime_to_rb_object;
 use super::{ObjectValue, Wrap, struct_dict};
 
 use crate::exceptions::RbOverflowError;
-use crate::rb_modules::utils;
+use crate::rb_modules::pl_utils;
 use crate::{RbErr, RbPolarsErr, RbResult, RbSeries};
 
 impl IntoValue for Wrap<AnyValue<'_>> {
@@ -33,7 +34,7 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::Int16(v) => ruby.into_value(v),
         AnyValue::Int32(v) => ruby.into_value(v),
         AnyValue::Int64(v) => ruby.into_value(v),
-        AnyValue::Int128(_v) => todo!(),
+        AnyValue::Int128(v) => ruby.into_value(v),
         AnyValue::Float32(v) => ruby.into_value(v),
         AnyValue::Float64(v) => ruby.into_value(v),
         AnyValue::Null => ruby.qnil().as_value(),
@@ -41,12 +42,12 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::String(v) => ruby.into_value(v),
         AnyValue::StringOwned(v) => ruby.into_value(v.as_str()),
         AnyValue::Categorical(cat, map) | AnyValue::Enum(cat, map) => unsafe {
-            map.cat_to_str_unchecked(cat).into_value()
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
         AnyValue::CategoricalOwned(cat, map) | AnyValue::EnumOwned(cat, map) => unsafe {
-            map.cat_to_str_unchecked(cat).into_value()
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
-        AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
+        AnyValue::Date(v) => pl_utils().funcall("_to_ruby_date", (v,)).unwrap(),
         AnyValue::Datetime(v, time_unit, time_zone) => {
             datetime_to_rb_object(v, time_unit, time_zone)
         }
@@ -55,14 +56,14 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
-            utils()
+            pl_utils()
                 .funcall("_to_ruby_duration", (v, time_unit))
                 .unwrap()
         }
-        AnyValue::Time(v) => utils().funcall("_to_ruby_time", (v,)).unwrap(),
-        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().into_value(),
-        ref av @ AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
-        AnyValue::StructOwned(payload) => struct_dict(payload.0.into_iter(), &payload.1),
+        AnyValue::Time(v) => pl_utils().funcall("_to_ruby_time", (v,)).unwrap(),
+        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().as_value(),
+        ref av @ AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
+        AnyValue::StructOwned(payload) => struct_dict(ruby, payload.0.into_iter(), &payload.1),
         AnyValue::Object(v) => {
             let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
             object.to_value()
@@ -71,21 +72,14 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
             let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
             object.to_value()
         }
-        AnyValue::Binary(v) => RString::from_slice(v).into_value(),
-        AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
-        AnyValue::Decimal(v, scale) => utils()
+        AnyValue::Binary(v) => ruby.str_from_slice(v).as_value(),
+        AnyValue::BinaryOwned(v) => ruby.str_from_slice(&v).as_value(),
+        AnyValue::Decimal(v, scale) => pl_utils()
             .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
             .unwrap(),
     }
 }
 
-fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
-    let tu = tu.to_ascii();
-    utils()
-        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
-        .unwrap()
-}
-
 pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<AnyValue<'s>> {
     // Conversion functions.
     fn get_null(_ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -117,8 +111,9 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_str(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
+        let ruby = Ruby::get_with(ob);
         let v = RString::from_value(ob).unwrap();
-        if v.enc_get() == Index::utf8() {
+        if v.enc_get() == ruby.utf8_encindex() {
             Ok(AnyValue::StringOwned(v.to_string()?.into()))
         } else {
             Ok(AnyValue::BinaryOwned(unsafe { v.as_slice() }.to_vec()))
@@ -237,24 +232,25 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         Ok(AnyValue::Decimal(v, scale))
     }
 
+    let ruby = Ruby::get_with(ob);
     if ob.is_nil() {
         get_null(ob, strict)
-    } else if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
+    } else if ob.is_kind_of(ruby.class_true_class()) || ob.is_kind_of(ruby.class_false_class()) {
         get_bool(ob, strict)
-    } else if ob.is_kind_of(class::integer()) {
+    } else if ob.is_kind_of(ruby.class_integer()) {
         get_int(ob, strict)
-    } else if ob.is_kind_of(class::float()) {
+    } else if ob.is_kind_of(ruby.class_float()) {
         get_float(ob, strict)
-    } else if ob.is_kind_of(class::string()) {
+    } else if ob.is_kind_of(ruby.class_string()) {
         get_str(ob, strict)
-    } else if ob.is_kind_of(class::array()) {
+    } else if ob.is_kind_of(ruby.class_array()) {
         get_list(ob, strict)
-    } else if ob.is_kind_of(class::hash()) {
+    } else if ob.is_kind_of(ruby.class_hash()) {
         get_struct(ob, strict)
     } else if ob.respond_to("_s", true)? {
         get_list_from_series(ob, strict)
     // call is_a? for ActiveSupport::TimeWithZone
-    } else if ob.funcall::<_, _, bool>("is_a?", (class::time(),))? {
+    } else if ob.funcall::<_, _, bool>("is_a?", (ruby.class_time(),))? {
         get_time(ob, strict)
     } else if ob.is_kind_of(crate::rb_modules::datetime()) {
         get_datetime(ob, strict)

data/ext/polars/src/conversion/chunked_array.rs

@@ -1,10 +1,10 @@
-use magnus::{IntoValue, RArray, RString, Ruby, TryConvert, Value, prelude::*};
+use magnus::{IntoValue, RString, Ruby, TryConvert, Value, prelude::*};
 use polars::prelude::*;
 
 use super::{Wrap, get_rbseq, struct_dict};
 
 use crate::RbResult;
-use crate::rb_modules::utils;
+use crate::rb_modules::pl_utils;
 
 impl TryConvert for Wrap<StringChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
@@ -39,19 +39,19 @@ impl TryConvert for Wrap<BinaryChunked> {
 }
 
 impl IntoValue for Wrap<&StringChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
+    fn into_value_with(self, ruby: &Ruby) -> Value {
         let iter = self.0.into_iter();
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&BinaryChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
+    fn into_value_with(self, ruby: &Ruby) -> Value {
         let iter = self
             .0
             .into_iter()
-            .map(|opt_bytes| opt_bytes.map(RString::from_slice));
-        RArray::from_iter(iter).into_value()
+            .map(|opt_bytes| opt_bytes.map(|v| ruby.str_from_slice(v)));
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
@@ -62,19 +62,19 @@ impl IntoValue for Wrap<&StructChunked> {
         // make series::iter() accept a chunk index.
         let s = s.rechunk();
         let iter = s.iter().map(|av| match av {
-            AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
+            AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
             AnyValue::Null => ruby.qnil().as_value(),
             _ => unreachable!(),
         });
 
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&DurationChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let time_unit = Wrap(self.0.time_unit()).into_value();
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let utils = pl_utils();
+        let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| {
                 utils
@@ -82,15 +82,19 @@ impl IntoValue for Wrap<&DurationChunked> {
                     .unwrap()
             })
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&DatetimeChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let time_unit = Wrap(self.0.time_unit()).into_value();
-        let time_zone = self.0.time_zone().as_deref().map(|v| v.into_value());
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let utils = pl_utils();
+        let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
+        let time_zone = self
+            .0
+            .time_zone()
+            .as_deref()
+            .map(|v| v.into_value_with(ruby));
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| {
                 utils
@@ -98,34 +102,34 @@ impl IntoValue for Wrap<&DatetimeChunked> {
                     .unwrap()
             })
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&TimeChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let utils = pl_utils();
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)).unwrap())
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&DateChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let utils = pl_utils();
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)).unwrap())
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&DecimalChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let rb_scale = (-(self.0.scale() as i32)).into_value();
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let utils = pl_utils();
+        let rb_scale = (-(self.0.scale() as i32)).into_value_with(ruby);
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| {
                 utils
@@ -133,6 +137,6 @@ impl IntoValue for Wrap<&DecimalChunked> {
                     .unwrap()
             })
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_from_iter(iter).as_value()
     }
 }

data/ext/polars/src/conversion/datetime.rs

@@ -0,0 +1,11 @@
+use magnus::{Value, prelude::*};
+use polars::prelude::*;
+
+use crate::rb_modules::pl_utils;
+
+pub fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
+    let tu = tu.to_ascii();
+    pl_utils()
+        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
+        .unwrap()
+}