bevy 1.0.0

data/ext/bevy/src/ruby_component.rs

@@ -0,0 +1,189 @@
+use bevy_ruby::{DynamicComponent, DynamicValue};
+use magnus::{function, method, prelude::*, Error, RHash, RModule, Ruby, Symbol, Value};
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+#[magnus::wrap(class = "Bevy::Component", free_immediately, size)]
+pub struct RubyComponent {
+    inner: RefCell<DynamicComponent>,
+}
+
+impl RubyComponent {
+    pub fn new(type_name: String) -> Self {
+        Self {
+            inner: RefCell::new(DynamicComponent::new(&type_name)),
+        }
+    }
+
+    pub fn from_dynamic(component: DynamicComponent) -> Self {
+        Self {
+            inner: RefCell::new(component),
+        }
+    }
+
+    pub fn inner(&self) -> DynamicComponent {
+        self.inner.borrow().clone()
+    }
+
+    fn type_name(&self) -> String {
+        self.inner.borrow().type_name().to_string()
+    }
+
+    fn get(&self, name: String) -> Result<Value, Error> {
+        let ruby = Ruby::get().unwrap();
+        let inner = self.inner.borrow();
+        match inner.get(&name) {
+            Some(value) => dynamic_value_to_ruby(&ruby, value),
+            None => Ok(ruby.qnil().as_value()),
+        }
+    }
+
+    fn set(&self, name: String, value: Value) -> Result<Value, Error> {
+        let dynamic_value = ruby_to_dynamic_value(value)?;
+        self.inner.borrow_mut().set(&name, dynamic_value);
+        Ok(value)
+    }
+
+    fn to_h(&self) -> Result<RHash, Error> {
+        let ruby = Ruby::get().unwrap();
+        let hash = ruby.hash_new();
+        let inner = self.inner.borrow();
+
+        for (key, value) in &inner.data {
+            let ruby_value = dynamic_value_to_ruby(&ruby, value)?;
+            hash.aset(ruby.to_symbol(key), ruby_value)?;
+        }
+
+        Ok(hash)
+    }
+
+    fn from_hash(type_name: String, hash: RHash) -> Result<Self, Error> {
+        let mut component = DynamicComponent::new(&type_name);
+
+        hash.foreach(|key: Value, value: Value| {
+            let key_str = if let Ok(sym) = Symbol::try_convert(key) {
+                sym.name().map(|s| s.to_string()).unwrap_or_default()
+            } else {
+                key.to_string()
+            };
+
+            if let Ok(dynamic_value) = ruby_to_dynamic_value(value) {
+                component.set(&key_str, dynamic_value);
+            }
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+
+        Ok(Self {
+            inner: RefCell::new(component),
+        })
+    }
+}
+
+unsafe impl Send for RubyComponent {}
+
+fn dynamic_value_to_ruby(ruby: &Ruby, value: &DynamicValue) -> Result<Value, Error> {
+    match value {
+        DynamicValue::Nil => Ok(ruby.qnil().as_value()),
+        DynamicValue::Boolean(b) => Ok(if *b {
+            ruby.qtrue().as_value()
+        } else {
+            ruby.qfalse().as_value()
+        }),
+        DynamicValue::Integer(i) => Ok(ruby.integer_from_i64(*i).as_value()),
+        DynamicValue::Float(f) => Ok(ruby.float_from_f64(*f).as_value()),
+        DynamicValue::String(s) => Ok(ruby.str_new(s).as_value()),
+        DynamicValue::Symbol(s) => Ok(ruby.to_symbol(s).as_value()),
+        DynamicValue::Array(arr) => {
+            let ruby_arr = ruby.ary_new();
+            for item in arr {
+                ruby_arr.push(dynamic_value_to_ruby(ruby, item)?)?;
+            }
+            Ok(ruby_arr.as_value())
+        }
+        DynamicValue::Hash(h) => {
+            let ruby_hash = ruby.hash_new();
+            for (k, v) in h {
+                ruby_hash.aset(ruby.to_symbol(k), dynamic_value_to_ruby(ruby, v)?)?;
+            }
+            Ok(ruby_hash.as_value())
+        }
+    }
+}
+
+fn ruby_to_dynamic_value(value: Value) -> Result<DynamicValue, Error> {
+    let ruby = Ruby::get().unwrap();
+
+    if value.is_nil() {
+        return Ok(DynamicValue::Nil);
+    }
+
+    if value.is_kind_of(ruby.class_true_class()) || value.is_kind_of(ruby.class_false_class()) {
+        if let Ok(b) = bool::try_convert(value) {
+            return Ok(DynamicValue::Boolean(b));
+        }
+    }
+
+    if value.is_kind_of(ruby.class_integer()) {
+        if let Ok(i) = i64::try_convert(value) {
+            return Ok(DynamicValue::Integer(i));
+        }
+    }
+
+    if value.is_kind_of(ruby.class_float()) {
+        if let Ok(f) = f64::try_convert(value) {
+            return Ok(DynamicValue::Float(f));
+        }
+    }
+
+    if let Ok(sym) = Symbol::try_convert(value) {
+        return Ok(DynamicValue::Symbol(
+            sym.name().map(|s| s.to_string()).unwrap_or_default(),
+        ));
+    }
+
+    if value.is_kind_of(ruby.class_string()) {
+        if let Ok(s) = String::try_convert(value) {
+            return Ok(DynamicValue::String(s));
+        }
+    }
+
+    if let Ok(arr) = magnus::RArray::try_convert(value) {
+        let mut result = Vec::new();
+        for item in arr.into_iter() {
+            result.push(ruby_to_dynamic_value(item)?);
+        }
+        return Ok(DynamicValue::Array(result));
+    }
+
+    if let Ok(hash) = RHash::try_convert(value) {
+        let mut result = HashMap::new();
+        hash.foreach(|k: Value, v: Value| {
+            let key = if let Ok(sym) = Symbol::try_convert(k) {
+                sym.name().map(|s| s.to_string()).unwrap_or_default()
+            } else {
+                k.to_string()
+            };
+            if let Ok(dv) = ruby_to_dynamic_value(v) {
+                result.insert(key, dv);
+            }
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+        return Ok(DynamicValue::Hash(result));
+    }
+
+    Err(Error::new(
+        ruby.exception_type_error(),
+        format!("Cannot convert {:?} to DynamicValue", value),
+    ))
+}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Component", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyComponent::new, 1))?;
+    class.define_singleton_method("from_hash", function!(RubyComponent::from_hash, 2))?;
+    class.define_method("type_name", method!(RubyComponent::type_name, 0))?;
+    class.define_method("[]", method!(RubyComponent::get, 1))?;
+    class.define_method("[]=", method!(RubyComponent::set, 2))?;
+    class.define_method("to_h", method!(RubyComponent::to_h, 0))?;
+    Ok(())
+}

data/ext/bevy/src/ruby_entity.rs

@@ -0,0 +1,33 @@
+use bevy_ruby::EntityWrapper;
+use magnus::{method, prelude::*, Error, RModule, Ruby};
+
+#[magnus::wrap(class = "Bevy::Entity", free_immediately, size)]
+pub struct RubyEntity {
+    inner: EntityWrapper,
+}
+
+impl RubyEntity {
+    pub fn new(entity: EntityWrapper) -> Self {
+        Self { inner: entity }
+    }
+
+    pub fn inner(&self) -> EntityWrapper {
+        self.inner
+    }
+
+    fn id(&self) -> u64 {
+        self.inner.id()
+    }
+}
+
+impl PartialEq for RubyEntity {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Entity", ruby.class_object())?;
+    class.define_method("id", method!(RubyEntity::id, 0))?;
+    Ok(())
+}

data/ext/bevy/src/ruby_math.rs

@@ -0,0 +1,384 @@
+use bevy_ruby::{RubyQuat, RubyVec2, RubyVec3};
+use magnus::{function, method, prelude::*, Error, RArray, RModule, Ruby};
+use std::cell::RefCell;
+
+#[magnus::wrap(class = "Bevy::Vec2", free_immediately, size)]
+pub struct MagnusVec2 {
+    inner: RefCell<RubyVec2>,
+}
+
+impl MagnusVec2 {
+    fn new(x: f64, y: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyVec2::new(x as f32, y as f32)),
+        }
+    }
+
+    fn zero() -> Self {
+        Self {
+            inner: RefCell::new(RubyVec2::zero()),
+        }
+    }
+
+    fn one() -> Self {
+        Self {
+            inner: RefCell::new(RubyVec2::one()),
+        }
+    }
+
+    fn x(&self) -> f64 {
+        self.inner.borrow().x() as f64
+    }
+
+    fn y(&self) -> f64 {
+        self.inner.borrow().y() as f64
+    }
+
+    fn set_x(&self, x: f64) {
+        self.inner.borrow_mut().set_x(x as f32);
+    }
+
+    fn set_y(&self, y: f64) {
+        self.inner.borrow_mut().set_y(y as f32);
+    }
+
+    fn length(&self) -> f64 {
+        self.inner.borrow().length() as f64
+    }
+
+    fn length_squared(&self) -> f64 {
+        self.inner.borrow().length_squared() as f64
+    }
+
+    fn normalize(&self) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().normalize()),
+        }
+    }
+
+    fn dot(&self, other: &MagnusVec2) -> f64 {
+        self.inner.borrow().dot(&other.inner.borrow()) as f64
+    }
+
+    fn add(&self, other: &MagnusVec2) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().add(&other.inner.borrow())),
+        }
+    }
+
+    fn sub(&self, other: &MagnusVec2) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().sub(&other.inner.borrow())),
+        }
+    }
+
+    fn mul(&self, scalar: f64) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().mul(scalar as f32)),
+        }
+    }
+
+    fn div(&self, scalar: f64) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().div(scalar as f32)),
+        }
+    }
+
+    fn distance(&self, other: &MagnusVec2) -> f64 {
+        self.inner.borrow().distance(&other.inner.borrow()) as f64
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let arr = ruby.ary_new();
+        let v = self.inner.borrow();
+        arr.push(v.x() as f64)?;
+        arr.push(v.y() as f64)?;
+        Ok(arr)
+    }
+
+    pub fn inner(&self) -> RubyVec2 {
+        *self.inner.borrow()
+    }
+}
+
+unsafe impl Send for MagnusVec2 {}
+
+#[magnus::wrap(class = "Bevy::Vec3", free_immediately, size)]
+pub struct MagnusVec3 {
+    inner: RefCell<RubyVec3>,
+}
+
+impl MagnusVec3 {
+    fn new(x: f64, y: f64, z: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyVec3::new(x as f32, y as f32, z as f32)),
+        }
+    }
+
+    fn zero() -> Self {
+        Self {
+            inner: RefCell::new(RubyVec3::zero()),
+        }
+    }
+
+    fn one() -> Self {
+        Self {
+            inner: RefCell::new(RubyVec3::one()),
+        }
+    }
+
+    fn x(&self) -> f64 {
+        self.inner.borrow().x() as f64
+    }
+
+    fn y(&self) -> f64 {
+        self.inner.borrow().y() as f64
+    }
+
+    fn z(&self) -> f64 {
+        self.inner.borrow().z() as f64
+    }
+
+    fn set_x(&self, x: f64) {
+        self.inner.borrow_mut().set_x(x as f32);
+    }
+
+    fn set_y(&self, y: f64) {
+        self.inner.borrow_mut().set_y(y as f32);
+    }
+
+    fn set_z(&self, z: f64) {
+        self.inner.borrow_mut().set_z(z as f32);
+    }
+
+    fn length(&self) -> f64 {
+        self.inner.borrow().length() as f64
+    }
+
+    fn length_squared(&self) -> f64 {
+        self.inner.borrow().length_squared() as f64
+    }
+
+    fn normalize(&self) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().normalize()),
+        }
+    }
+
+    fn dot(&self, other: &MagnusVec3) -> f64 {
+        self.inner.borrow().dot(&other.inner.borrow()) as f64
+    }
+
+    fn cross(&self, other: &MagnusVec3) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().cross(&other.inner.borrow())),
+        }
+    }
+
+    fn add(&self, other: &MagnusVec3) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().add(&other.inner.borrow())),
+        }
+    }
+
+    fn sub(&self, other: &MagnusVec3) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().sub(&other.inner.borrow())),
+        }
+    }
+
+    fn mul(&self, scalar: f64) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().mul(scalar as f32)),
+        }
+    }
+
+    fn div(&self, scalar: f64) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().div(scalar as f32)),
+        }
+    }
+
+    fn distance(&self, other: &MagnusVec3) -> f64 {
+        self.inner.borrow().distance(&other.inner.borrow()) as f64
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let arr = ruby.ary_new();
+        let v = self.inner.borrow();
+        arr.push(v.x() as f64)?;
+        arr.push(v.y() as f64)?;
+        arr.push(v.z() as f64)?;
+        Ok(arr)
+    }
+
+    pub fn inner(&self) -> RubyVec3 {
+        *self.inner.borrow()
+    }
+}
+
+unsafe impl Send for MagnusVec3 {}
+
+#[magnus::wrap(class = "Bevy::Quat", free_immediately, size)]
+pub struct MagnusQuat {
+    inner: RefCell<RubyQuat>,
+}
+
+impl MagnusQuat {
+    fn identity() -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::identity()),
+        }
+    }
+
+    fn from_axis_angle(axis: &MagnusVec3, angle: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::from_axis_angle(&axis.inner(), angle as f32)),
+        }
+    }
+
+    fn from_euler(x: f64, y: f64, z: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::from_euler(x as f32, y as f32, z as f32)),
+        }
+    }
+
+    fn from_rotation_x(angle: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::from_rotation_x(angle as f32)),
+        }
+    }
+
+    fn from_rotation_y(angle: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::from_rotation_y(angle as f32)),
+        }
+    }
+
+    fn from_rotation_z(angle: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyQuat::from_rotation_z(angle as f32)),
+        }
+    }
+
+    fn x(&self) -> f64 {
+        self.inner.borrow().x() as f64
+    }
+
+    fn y(&self) -> f64 {
+        self.inner.borrow().y() as f64
+    }
+
+    fn z(&self) -> f64 {
+        self.inner.borrow().z() as f64
+    }
+
+    fn w(&self) -> f64 {
+        self.inner.borrow().w() as f64
+    }
+
+    fn normalize(&self) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().normalize()),
+        }
+    }
+
+    fn inverse(&self) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().inverse()),
+        }
+    }
+
+    fn mul_quat(&self, other: &MagnusQuat) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().mul(&other.inner.borrow())),
+        }
+    }
+
+    fn mul_vec3(&self, v: &MagnusVec3) -> MagnusVec3 {
+        MagnusVec3 {
+            inner: RefCell::new(self.inner.borrow().mul_vec3(&v.inner())),
+        }
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let arr = ruby.ary_new();
+        let q = self.inner.borrow();
+        arr.push(q.x() as f64)?;
+        arr.push(q.y() as f64)?;
+        arr.push(q.z() as f64)?;
+        arr.push(q.w() as f64)?;
+        Ok(arr)
+    }
+
+    pub fn inner(&self) -> RubyQuat {
+        *self.inner.borrow()
+    }
+}
+
+unsafe impl Send for MagnusQuat {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let vec2_class = module.define_class("Vec2", ruby.class_object())?;
+    vec2_class.define_singleton_method("new", function!(MagnusVec2::new, 2))?;
+    vec2_class.define_singleton_method("zero", function!(MagnusVec2::zero, 0))?;
+    vec2_class.define_singleton_method("one", function!(MagnusVec2::one, 0))?;
+    vec2_class.define_method("x", method!(MagnusVec2::x, 0))?;
+    vec2_class.define_method("y", method!(MagnusVec2::y, 0))?;
+    vec2_class.define_method("x=", method!(MagnusVec2::set_x, 1))?;
+    vec2_class.define_method("y=", method!(MagnusVec2::set_y, 1))?;
+    vec2_class.define_method("length", method!(MagnusVec2::length, 0))?;
+    vec2_class.define_method("length_squared", method!(MagnusVec2::length_squared, 0))?;
+    vec2_class.define_method("normalize", method!(MagnusVec2::normalize, 0))?;
+    vec2_class.define_method("dot", method!(MagnusVec2::dot, 1))?;
+    vec2_class.define_method("+", method!(MagnusVec2::add, 1))?;
+    vec2_class.define_method("-", method!(MagnusVec2::sub, 1))?;
+    vec2_class.define_method("*", method!(MagnusVec2::mul, 1))?;
+    vec2_class.define_method("/", method!(MagnusVec2::div, 1))?;
+    vec2_class.define_method("distance", method!(MagnusVec2::distance, 1))?;
+    vec2_class.define_method("to_a", method!(MagnusVec2::to_a, 0))?;
+
+    let vec3_class = module.define_class("Vec3", ruby.class_object())?;
+    vec3_class.define_singleton_method("new", function!(MagnusVec3::new, 3))?;
+    vec3_class.define_singleton_method("zero", function!(MagnusVec3::zero, 0))?;
+    vec3_class.define_singleton_method("one", function!(MagnusVec3::one, 0))?;
+    vec3_class.define_method("x", method!(MagnusVec3::x, 0))?;
+    vec3_class.define_method("y", method!(MagnusVec3::y, 0))?;
+    vec3_class.define_method("z", method!(MagnusVec3::z, 0))?;
+    vec3_class.define_method("x=", method!(MagnusVec3::set_x, 1))?;
+    vec3_class.define_method("y=", method!(MagnusVec3::set_y, 1))?;
+    vec3_class.define_method("z=", method!(MagnusVec3::set_z, 1))?;
+    vec3_class.define_method("length", method!(MagnusVec3::length, 0))?;
+    vec3_class.define_method("length_squared", method!(MagnusVec3::length_squared, 0))?;
+    vec3_class.define_method("normalize", method!(MagnusVec3::normalize, 0))?;
+    vec3_class.define_method("dot", method!(MagnusVec3::dot, 1))?;
+    vec3_class.define_method("cross", method!(MagnusVec3::cross, 1))?;
+    vec3_class.define_method("+", method!(MagnusVec3::add, 1))?;
+    vec3_class.define_method("-", method!(MagnusVec3::sub, 1))?;
+    vec3_class.define_method("*", method!(MagnusVec3::mul, 1))?;
+    vec3_class.define_method("/", method!(MagnusVec3::div, 1))?;
+    vec3_class.define_method("distance", method!(MagnusVec3::distance, 1))?;
+    vec3_class.define_method("to_a", method!(MagnusVec3::to_a, 0))?;
+
+    let quat_class = module.define_class("Quat", ruby.class_object())?;
+    quat_class.define_singleton_method("identity", function!(MagnusQuat::identity, 0))?;
+    quat_class.define_singleton_method("from_axis_angle", function!(MagnusQuat::from_axis_angle, 2))?;
+    quat_class.define_singleton_method("from_euler", function!(MagnusQuat::from_euler, 3))?;
+    quat_class.define_singleton_method("from_rotation_x", function!(MagnusQuat::from_rotation_x, 1))?;
+    quat_class.define_singleton_method("from_rotation_y", function!(MagnusQuat::from_rotation_y, 1))?;
+    quat_class.define_singleton_method("from_rotation_z", function!(MagnusQuat::from_rotation_z, 1))?;
+    quat_class.define_method("x", method!(MagnusQuat::x, 0))?;
+    quat_class.define_method("y", method!(MagnusQuat::y, 0))?;
+    quat_class.define_method("z", method!(MagnusQuat::z, 0))?;
+    quat_class.define_method("w", method!(MagnusQuat::w, 0))?;
+    quat_class.define_method("normalize", method!(MagnusQuat::normalize, 0))?;
+    quat_class.define_method("inverse", method!(MagnusQuat::inverse, 0))?;
+    quat_class.define_method("*", method!(MagnusQuat::mul_quat, 1))?;
+    quat_class.define_method("mul_vec3", method!(MagnusQuat::mul_vec3, 1))?;
+    quat_class.define_method("to_a", method!(MagnusQuat::to_a, 0))?;
+
+    Ok(())
+}

data/ext/bevy/src/ruby_query.rs

@@ -0,0 +1,64 @@
+use bevy_ruby::QueryBuilder;
+use magnus::{function, method, prelude::*, Error, RArray, RModule, Ruby};
+use std::cell::RefCell;
+
+#[magnus::wrap(class = "Bevy::QueryBuilder", free_immediately, size)]
+pub struct RubyQueryBuilder {
+    inner: RefCell<QueryBuilder>,
+}
+
+impl RubyQueryBuilder {
+    fn new() -> Self {
+        Self {
+            inner: RefCell::new(QueryBuilder::new()),
+        }
+    }
+
+    fn fetch(&self, component_name: String) -> Self {
+        let builder = self.inner.borrow().clone().fetch(&component_name);
+        Self {
+            inner: RefCell::new(builder),
+        }
+    }
+
+    fn fetch_components(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let components = self.inner.borrow();
+        let fetch = components.fetch_components();
+        let array = ruby.ary_new_capa(fetch.len());
+        for name in fetch {
+            let _ = array.push(name.clone());
+        }
+        array
+    }
+
+    fn with_filter(&self, component_name: String) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().clone().fetch(&component_name)),
+        }
+    }
+
+    fn without_filter(&self, _component_name: String) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().clone()),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn inner(&self) -> QueryBuilder {
+        self.inner.borrow().clone()
+    }
+}
+
+unsafe impl Send for RubyQueryBuilder {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("QueryBuilder", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyQueryBuilder::new, 0))?;
+    class.define_method("fetch", method!(RubyQueryBuilder::fetch, 1))?;
+    class.define_method("fetch_components", method!(RubyQueryBuilder::fetch_components, 0))?;
+    class.define_method("with", method!(RubyQueryBuilder::with_filter, 1))?;
+    class.define_method("without", method!(RubyQueryBuilder::without_filter, 1))?;
+
+    Ok(())
+}