bluejay 0.1.0.alpha.1

data/ext/src/helpers/wrapped_definition.rs

@@ -0,0 +1,79 @@
+use once_cell::unsync::OnceCell;
+use magnus::{RClass, TypedData, Error, Module, exception, gc, TryConvert, Value};
+use super::WrappedStruct;
+
+pub trait HasDefinitionWrapper: TypedData {
+    fn wrapping_class() -> RClass;
+}
+
+#[derive(Debug)]
+pub struct WrappedDefinition<T: HasDefinitionWrapper> {
+    cls: RClass,
+    memoized_definition: OnceCell<WrappedStruct<T>>,
+}
+
+impl<T: HasDefinitionWrapper> Clone for WrappedDefinition<T> {
+    fn clone(&self) -> Self {
+        Self { cls: self.cls.clone(), memoized_definition: self.memoized_definition.clone() }
+    }
+}
+
+impl<T: HasDefinitionWrapper> WrappedDefinition<T> {
+    pub fn new(cls: RClass) -> Result<Self, Error> {
+        if cls.is_inherited(T::wrapping_class()) {
+            Ok(Self { cls, memoized_definition: OnceCell::new() })
+        } else {
+            Err(Error::new(
+                exception::type_error(),
+                format!(
+                    "no implicit conversion of {} into {}",
+                    cls,
+                    T::wrapping_class()
+                ),
+            ))
+        }
+    }
+
+    pub fn get(&self) -> &WrappedStruct<T> {
+        self.memoized_definition
+            .get_or_init(|| self.cls.funcall("definition", ()).unwrap())
+    }
+
+    pub fn mark(&self) {
+        gc::mark(self.cls);
+        if let Some(ws) = self.memoized_definition.get() {
+            ws.mark();
+        }
+    }
+
+    pub fn fully_qualified_name(&self) -> String {
+        unsafe { self.cls.name() }.into_owned()
+    }
+
+    pub fn class(&self) -> RClass {
+        self.cls
+    }
+}
+
+impl<T: HasDefinitionWrapper> TryConvert for WrappedDefinition<T> {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let cls = RClass::from_value(val).ok_or_else(|| {
+            Error::new(
+                exception::type_error(),
+                format!(
+                    "no implicit conversion of {} into {}",
+                    unsafe { val.classname() },
+                    T::wrapping_class()
+                ),
+            )
+        })?;
+
+        Self::new(cls)
+    }
+}
+
+impl<T: HasDefinitionWrapper> AsRef<T> for WrappedDefinition<T> {
+    fn as_ref(&self) -> &T {
+        self.get().as_ref()
+    }
+}

data/ext/src/helpers/wrapped_struct.rs

@@ -0,0 +1,97 @@
+use magnus::{error::Error, exception, gc, value::Value, RTypedData, TryConvert, TypedData};
+use std::{marker::PhantomData, ops::Deref};
+
+/// A small wrapper for `RTypedData` that keeps track of the concrete struct
+/// type, and the underlying [`Value`] for GC purposes.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct WrappedStruct<T: TypedData> {
+    inner: RTypedData,
+    phantom: PhantomData<T>,
+}
+
+impl<T: TypedData> Copy for WrappedStruct<T>  {}
+
+impl<T: TypedData> Clone for WrappedStruct<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: TypedData> WrappedStruct<T> {
+    /// Gets the underlying struct.
+    pub fn get(&self) -> &T {
+        self.inner.get().unwrap()
+    }
+
+    /// Get the Ruby [`Value`] for this struct.
+    pub fn to_value(&self) -> Value {
+        self.inner.into()
+    }
+
+    /// Marks the Ruby [`Value`] for GC.
+    pub fn mark(&self) {
+        gc::mark(&self.inner.into());
+    }
+
+    pub fn wrap(data: T) -> Self {
+        let inner = RTypedData::wrap(data);
+        Self {
+            inner,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<T: TypedData> From<WrappedStruct<T>> for Value {
+    fn from(wrapped_struct: WrappedStruct<T>) -> Self {
+        wrapped_struct.to_value()
+    }
+}
+
+impl<T: TypedData> Deref for WrappedStruct<T> {
+    type Target = RTypedData;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T: TypedData> From<T> for WrappedStruct<T> {
+    fn from(t: T) -> Self {
+        Self {
+            inner: RTypedData::wrap(t).into(),
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<T> TryConvert for WrappedStruct<T>
+where
+    T: TypedData,
+{
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let inner = RTypedData::from_value(val).ok_or_else(|| {
+            Error::new(
+                exception::type_error(),
+                format!(
+                    "no implicit conversion of {} into {}",
+                    unsafe { val.classname() },
+                    T::class()
+                ),
+            )
+        })?;
+        inner.get::<T>()?;
+
+        Ok(Self {
+            inner,
+            phantom: PhantomData,
+        })
+    }
+}
+
+impl<T: TypedData> AsRef<T> for WrappedStruct<T> {
+    fn as_ref(&self) -> &T {
+        self.get()
+    }
+}

data/ext/src/helpers.rs

@@ -0,0 +1,8 @@
+mod wrapped_definition;
+pub use wrapped_definition::{HasDefinitionWrapper, WrappedDefinition};
+mod public_name;
+pub use public_name::public_name;
+mod typed_frozen_r_array;
+pub use typed_frozen_r_array::TypedFrozenRArray;
+mod wrapped_struct;
+pub use wrapped_struct::WrappedStruct;

data/ext/src/lib.rs

@@ -0,0 +1,10 @@
+use magnus::{Error};
+
+mod execution;
+mod helpers;
+mod ruby_api;
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    ruby_api::init()
+}

data/ext/src/ruby_api/arguments_definition.rs

@@ -0,0 +1,8 @@
+use super::{input_value_definition::InputValueDefinition};
+use crate::helpers::{WrappedStruct, TypedFrozenRArray};
+
+pub type ArgumentsDefinition = TypedFrozenRArray<WrappedStruct<InputValueDefinition>>;
+
+impl bluejay_core::definition::ArgumentsDefinition for ArgumentsDefinition {
+    type ArgumentDefinition = InputValueDefinition;
+}

data/ext/src/ruby_api/coerce_input.rs

@@ -0,0 +1,6 @@
+use super::coercion_error::CoercionError;
+use magnus::{Value, Error};
+
+pub trait CoerceInput {
+    fn coerce_input(&self, value: Value, path: &[String]) -> Result<Result<Value, Vec<CoercionError>>, Error>;
+}

data/ext/src/ruby_api/coercion_error.rs

@@ -0,0 +1,61 @@
+use super::{root, ExecutionError};
+use crate::helpers::WrappedStruct;
+use magnus::{function, Error, Module, Object, RArray, Value, method, rb_sys::AsRawValue};
+
+#[derive(Clone, Debug, PartialEq)]
+#[magnus::wrap(class = "Bluejay::CoercionError", mark)]
+pub struct CoercionError {
+    message: String,
+    path: Vec<String>,
+}
+
+impl CoercionError {
+    pub fn new(message: String, path: Vec<String>) -> Self {
+        Self { message, path }
+    }
+
+    pub fn message(&self) -> &str {
+        self.message.as_str()
+    }
+
+    pub fn path(&self) -> RArray {
+        RArray::from_iter(self.path.iter().map(|s| s.as_str()))
+    }
+
+    pub fn eql(&self, other: Value) -> bool {
+        if let Ok(other) = other.try_convert::<&Self>() {
+            self == other
+        } else {
+            false
+        }
+    }
+
+    fn inspect(rb_self: WrappedStruct<Self>) -> Result<String, Error> {
+        let rs_self = rb_self.get();
+
+        Ok(format!(
+            "#<Bluejay::CoercionError:0x{:016x} @message={:?} @path={:?}>",
+            rb_self.to_value().as_raw(),
+            rs_self.message,
+            rs_self.path,
+        ))
+    }
+}
+
+impl Into<ExecutionError> for CoercionError {
+    fn into(self) -> ExecutionError {
+        ExecutionError::new(self.message)
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("CoercionError", Default::default())?;
+
+    class.define_singleton_method("new", function!(CoercionError::new, 2))?;
+    class.define_method("message", method!(CoercionError::message, 0))?;
+    class.define_method("path", method!(CoercionError::path, 0))?;
+    class.define_method("==", method!(CoercionError::eql, 1))?;
+    class.define_method("inspect", method!(CoercionError::inspect, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/custom_scalar_type_definition.rs

@@ -0,0 +1,62 @@
+use magnus::{function, Error, Module, Object, Value, scan_args::get_kwargs, RHash, memoize, TypedData, DataTypeFunctions, RClass};
+use super::{root, coerce_input::CoerceInput, coercion_error::CoercionError};
+use crate::helpers::{HasDefinitionWrapper};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::CustomScalarTypeDefinition", mark)]
+pub struct CustomScalarTypeDefinition {
+    name: String,
+    description: Option<String>,
+}
+
+// TODO: add ability to coerce input and possibly coerce result
+
+impl CustomScalarTypeDefinition {
+    fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "description"], &[])?;
+        let (name, description): (String, Option<String>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        Ok(Self { name, description })
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+}
+
+impl DataTypeFunctions for CustomScalarTypeDefinition {}
+
+impl HasDefinitionWrapper for CustomScalarTypeDefinition {
+    fn wrapping_class() -> RClass {
+        *memoize!(RClass: root().define_class("CustomScalarType", Default::default()).unwrap())
+    }
+}
+
+impl CoerceInput for CustomScalarTypeDefinition {
+    fn coerce_input(&self, value: Value, _path: &[String]) -> Result<Result<Value, Vec<CoercionError>>, Error> {
+        Ok(Ok(value))
+    }
+}
+
+impl bluejay_core::definition::ScalarTypeDefinition for CustomScalarTypeDefinition {
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(|s| s.as_str())
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("CustomScalarTypeDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(CustomScalarTypeDefinition::new, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/enum_type_definition.rs

@@ -0,0 +1,107 @@
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, Value, memoize, TypedData, RArray, DataTypeFunctions, RClass, gc};
+use bluejay_core::AsIter;
+use super::{root, enum_value_definitions::EnumValueDefinitions, coerce_input::CoerceInput, coercion_error::CoercionError};
+use crate::helpers::{public_name, HasDefinitionWrapper};
+use crate::execution::{FieldError, CoerceResult};
+
+#[derive(Debug, TypedData)]
+#[magnus(class = "Bluejay::EnumTypeDefinition", mark)]
+pub struct EnumTypeDefinition {
+    name: String,
+    description: Option<String>,
+    enum_value_definitions: EnumValueDefinitions,
+}
+
+impl EnumTypeDefinition {
+    fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "enum_value_definitions", "description"], &[])?;
+        let (name, enum_value_definitions, description): (String, RArray, Option<String>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let enum_value_definitions = EnumValueDefinitions::new(enum_value_definitions)?;
+        Ok(Self { name, description, enum_value_definitions })
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    pub fn enum_value_definitions(&self) -> &EnumValueDefinitions {
+        &self.enum_value_definitions
+    }
+}
+
+impl DataTypeFunctions for EnumTypeDefinition {
+    fn mark(&self) {
+        gc::mark(self.enum_value_definitions);
+    }
+}
+
+impl CoerceInput for EnumTypeDefinition {
+    fn coerce_input(&self, value: Value, path: &[String]) -> Result<Result<Value, Vec<CoercionError>>, Error> {
+        let s: Result<String, _> = value.try_convert();
+        match s {
+            Ok(s) => {
+                // TODO: don't use const_get
+                if self.enum_value_definitions.iter().any(|evd| evd.name() == s.as_str()) {
+                    Ok(Ok(value))
+                } else {
+                    Ok(Err(vec![CoercionError::new(
+                        format!("No member `{}` on {}", s.as_str(), self.name.as_str()),
+                        path.to_owned(),
+                    )]))
+                }
+            },
+            Err(_) => {
+                Ok(Err(vec![CoercionError::new(
+                    format!("No implicit conversion of {} to {}", public_name(value), self.name.as_str()),
+                    path.to_owned(),
+                )]))
+            }
+        }
+    }
+}
+
+impl HasDefinitionWrapper for EnumTypeDefinition {
+    fn wrapping_class() -> RClass {
+        *memoize!(RClass: root().define_class("EnumType", Default::default()).unwrap())
+    }
+}
+
+impl bluejay_core::definition::EnumTypeDefinition for EnumTypeDefinition {
+    type EnumValueDefinitions = EnumValueDefinitions;
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn enum_value_definitions(&self) -> &Self::EnumValueDefinitions {
+        &self.enum_value_definitions
+    }
+}
+
+impl CoerceResult for EnumTypeDefinition {
+    fn coerce_result(&self, value: Value) -> Result<Value, FieldError> {
+        if value.try_convert().ok().map(|value: String| self.enum_value_definitions.iter().any(|evd| evd.name() == value.as_str())).unwrap_or(false) {
+            Ok(value)
+        } else {
+            Err(FieldError::CannotCoerceResultToEnumType)
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("EnumTypeDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(EnumTypeDefinition::new, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/enum_value_definition.rs

@@ -0,0 +1,58 @@
+use super::root;
+use crate::helpers::WrappedStruct;
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, TypedData, DataTypeFunctions, method};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::EnumValueDefinition", mark)]
+pub struct EnumValueDefinition {
+    name: String,
+    description: Option<String>,
+}
+
+impl EnumValueDefinition {
+    pub fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name"], &["description"])?;
+        let (name,): (String,) = args.required;
+        let (description,): (Option<String>,) = args.optional;
+        let _: () = args.splat;
+        Ok(Self { name, description })
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+impl DataTypeFunctions for EnumValueDefinition {
+    fn mark(&self) {
+    }
+}
+
+impl bluejay_core::definition::EnumValueDefinition for EnumValueDefinition {
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+impl bluejay_core::definition::EnumValueDefinition for WrappedStruct<EnumValueDefinition> {
+    fn description(&self) -> Option<&str> {
+        self.get().description()
+    }
+
+    fn name(&self) -> &str {
+        self.get().name()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("EnumValueDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(EnumValueDefinition::new, 1))?;
+    class.define_method("name", method!(EnumValueDefinition::name, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/enum_value_definitions.rs

@@ -0,0 +1,8 @@
+use super::{enum_value_definition::EnumValueDefinition};
+use crate::helpers::{WrappedStruct, TypedFrozenRArray};
+
+pub type EnumValueDefinitions = TypedFrozenRArray<WrappedStruct<EnumValueDefinition>>;
+
+impl bluejay_core::definition::EnumValueDefinitions for EnumValueDefinitions {
+    type EnumValueDefinition = EnumValueDefinition;
+}

data/ext/src/ruby_api/execution_error.rs

@@ -0,0 +1,48 @@
+use super::root;
+use crate::helpers::WrappedStruct;
+use magnus::{function, Error, Module, Object, Value, method, rb_sys::AsRawValue};
+
+#[derive(Clone, Debug, PartialEq)]
+#[magnus::wrap(class = "Bluejay::ExecutionError", mark)]
+pub struct ExecutionError {
+    message: String,
+}
+
+impl ExecutionError {
+    pub fn new(message: String) -> Self {
+        Self { message }
+    }
+
+    pub fn message(&self) -> &str {
+        self.message.as_str()
+    }
+
+    pub fn eql(&self, other: Value) -> bool {
+        if let Ok(other) = other.try_convert::<&Self>() {
+            self == other
+        } else {
+            false
+        }
+    }
+
+    fn inspect(rb_self: WrappedStruct<Self>) -> Result<String, Error> {
+        let rs_self = rb_self.get();
+
+        Ok(format!(
+            "#<Bluejay::ExecutionError:0x{:016x} @message={:?}>",
+            rb_self.to_value().as_raw(),
+            rs_self.message,
+        ))
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("ExecutionError", Default::default())?;
+
+    class.define_singleton_method("new", function!(ExecutionError::new, 1))?;
+    class.define_method("message", method!(ExecutionError::message, 0))?;
+    class.define_method("==", method!(ExecutionError::eql, 1))?;
+    class.define_method("inspect", method!(ExecutionError::inspect, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/execution_result.rs

@@ -0,0 +1,40 @@
+use super::root;
+use super::ExecutionError;
+use crate::helpers::{WrappedStruct};
+use magnus::{gc, Error, Module, RArray, Value, TypedData, DataTypeFunctions, method};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::ExecutionResult", mark)]
+pub struct ExecutionResult {
+    value: Value,
+    errors: Vec<WrappedStruct<ExecutionError>>,
+}
+
+impl ExecutionResult {
+    pub fn new(value: Value, errors: Vec<WrappedStruct<ExecutionError>>) -> Self {
+        Self { value, errors }
+    }
+
+    fn value(&self) -> Value {
+        self.value
+    }
+
+    fn errors(&self) -> RArray {
+        RArray::from_iter(self.errors.iter().map(|err| *err))
+    }
+}
+
+impl DataTypeFunctions for ExecutionResult {
+    fn mark(&self) {
+        gc::mark(&self.value);
+        self.errors.iter().for_each(WrappedStruct::mark);
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("ExecutionResult", Default::default())?;
+    class.define_method("value", method!(ExecutionResult::value, 0))?;
+    class.define_method("errors", method!(ExecutionResult::errors, 0))?;
+
+    Ok(())
+}