mustardscript 0.1.0 → 0.1.2

package/crates/mustard/src/runtime/conversions/boundary.rs

@@ -1,293 +0,0 @@
-use super::*;
-
-const STRUCTURED_BOUNDARY_MAX_DEPTH: usize = 128;
-
-#[derive(Default)]
-struct StructuredTraversalState {
-    active_arrays: HashSet<ArrayKey>,
-    active_objects: HashSet<ObjectKey>,
-    seen_arrays: HashSet<ArrayKey>,
-    seen_objects: HashSet<ObjectKey>,
-}
-
-impl Runtime {
-    pub(in crate::runtime) fn value_from_structured(
-        &mut self,
-        value: StructuredValue,
-    ) -> MustardResult<Value> {
-        self.value_from_structured_inner(value, 1)
-    }
-
-    fn value_from_structured_inner(
-        &mut self,
-        value: StructuredValue,
-        depth: usize,
-    ) -> MustardResult<Value> {
-        ensure_nested_depth(depth, structured_boundary_depth_error)?;
-        self.charge_native_helper_work(1)?;
-        Ok(match value {
-            StructuredValue::Undefined => Value::Undefined,
-            StructuredValue::Null => Value::Null,
-            StructuredValue::Hole => {
-                return Err(MustardError::runtime(
-                    "array holes can only appear inside structured arrays",
-                ));
-            }
-            StructuredValue::Bool(value) => Value::Bool(value),
-            StructuredValue::String(value) => {
-                self.ensure_heap_capacity(value.len())?;
-                Value::String(value)
-            }
-            StructuredValue::Number(number) => Value::Number(number.to_f64()),
-            StructuredValue::Array(items) => {
-                let mut values = Vec::with_capacity(items.len());
-                for item in items {
-                    values.push(match item {
-                        StructuredValue::Hole => None,
-                        other => Some(self.value_from_structured_inner(other, depth + 1)?),
-                    });
-                }
-                let array = self.insert_sparse_array(values, IndexMap::new())?;
-                Value::Array(array)
-            }
-            StructuredValue::Object(object) => {
-                let mut properties = IndexMap::new();
-                for (key, value) in object {
-                    properties.insert(key, self.value_from_structured_inner(value, depth + 1)?);
-                }
-                let object = self.insert_object(properties, ObjectKind::Plain)?;
-                Value::Object(object)
-            }
-        })
-    }
-
-    pub(in crate::runtime) fn value_to_structured(
-        &mut self,
-        value: Value,
-    ) -> MustardResult<StructuredValue> {
-        let mut traversal = StructuredTraversalState::default();
-        self.value_to_structured_inner(value, &mut traversal, 1)
-    }
-
-    fn value_to_structured_inner(
-        &mut self,
-        value: Value,
-        traversal: &mut StructuredTraversalState,
-        depth: usize,
-    ) -> MustardResult<StructuredValue> {
-        ensure_nested_depth(depth, structured_boundary_depth_error)?;
-        self.charge_native_helper_work(1)?;
-        Ok(match value {
-            Value::Undefined => StructuredValue::Undefined,
-            Value::Null => StructuredValue::Null,
-            Value::Bool(value) => StructuredValue::Bool(value),
-            Value::Number(value) => StructuredValue::Number(StructuredNumber::from_f64(value)),
-            Value::BigInt(_) => {
-                return Err(MustardError::runtime(
-                    "BigInt values cannot cross the structured host boundary",
-                ));
-            }
-            Value::String(value) => {
-                self.ensure_heap_capacity(value.len())?;
-                StructuredValue::String(value)
-            }
-            Value::Array(array) => {
-                if !traversal.active_arrays.insert(array) {
-                    return Err(structured_boundary_cycle_error());
-                }
-                if !traversal.seen_arrays.insert(array) {
-                    traversal.active_arrays.remove(&array);
-                    return Err(structured_boundary_shared_reference_error());
-                }
-                let elements = self
-                    .arrays
-                    .get(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?
-                    .elements
-                    .clone();
-                let result = (|| {
-                    Ok(StructuredValue::Array(
-                        elements
-                            .iter()
-                            .map(|value| match value {
-                                Some(value) => self.value_to_structured_inner(
-                                    value.clone(),
-                                    traversal,
-                                    depth + 1,
-                                ),
-                                None => Ok(StructuredValue::Hole),
-                            })
-                            .collect::<MustardResult<Vec<_>>>()?,
-                    ))
-                })();
-                traversal.active_arrays.remove(&array);
-                result?
-            }
-            Value::Object(object) => {
-                let object_ref = self
-                    .objects
-                    .get(object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?;
-                match &object_ref.kind {
-                    ObjectKind::Plain => {}
-                    ObjectKind::Date(_) => {
-                        return Err(MustardError::runtime(
-                            "Date values cannot cross the structured host boundary",
-                        ));
-                    }
-                    _ => {
-                        return Err(MustardError::runtime(
-                            "only plain objects can cross the structured host boundary",
-                        ));
-                    }
-                }
-                if !traversal.active_objects.insert(object) {
-                    return Err(structured_boundary_cycle_error());
-                }
-                if !traversal.seen_objects.insert(object) {
-                    traversal.active_objects.remove(&object);
-                    return Err(structured_boundary_shared_reference_error());
-                }
-                let properties = object_ref.properties.clone();
-                let result = (|| {
-                    Ok(StructuredValue::Object(
-                        properties
-                            .iter()
-                            .map(|(key, value)| {
-                                Ok((
-                                    key.clone(),
-                                    self.value_to_structured_inner(
-                                        value.clone(),
-                                        traversal,
-                                        depth + 1,
-                                    )?,
-                                ))
-                            })
-                            .collect::<MustardResult<IndexMap<_, _>>>()?,
-                    ))
-                })();
-                traversal.active_objects.remove(&object);
-                result?
-            }
-            Value::Map(_) | Value::Set(_) => {
-                return Err(MustardError::runtime(
-                    "Map and Set values cannot cross the structured host boundary",
-                ));
-            }
-            Value::Iterator(_)
-            | Value::Promise(_)
-            | Value::Closure(_)
-            | Value::BuiltinFunction(_)
-            | Value::HostFunction(_) => {
-                return Err(MustardError::runtime(
-                    "functions cannot cross the structured host boundary",
-                ));
-            }
-        })
-    }
-
-    pub(in crate::runtime) fn value_from_json(
-        &mut self,
-        value: serde_json::Value,
-    ) -> MustardResult<Value> {
-        self.value_from_json_inner(value, 1)
-    }
-
-    fn value_from_json_inner(
-        &mut self,
-        value: serde_json::Value,
-        depth: usize,
-    ) -> MustardResult<Value> {
-        ensure_nested_depth(depth, json_value_depth_error)?;
-        self.charge_native_helper_work(1)?;
-        match value {
-            serde_json::Value::Null => Ok(Value::Null),
-            serde_json::Value::Bool(value) => Ok(Value::Bool(value)),
-            serde_json::Value::Number(number) => Ok(Value::Number(number.as_f64().unwrap_or(0.0))),
-            serde_json::Value::String(value) => {
-                self.ensure_heap_capacity(value.len())?;
-                Ok(Value::String(value))
-            }
-            serde_json::Value::Array(items) => {
-                let mut values = Vec::with_capacity(items.len());
-                for item in items {
-                    values.push(self.value_from_json_inner(item, depth + 1)?);
-                }
-                let array = self.insert_array(values, IndexMap::new())?;
-                Ok(Value::Array(array))
-            }
-            serde_json::Value::Object(object) => {
-                let mut properties = IndexMap::new();
-                for (key, value) in object {
-                    properties.insert(key, self.value_from_json_inner(value, depth + 1)?);
-                }
-                let object = self.insert_object(properties, ObjectKind::Plain)?;
-                Ok(Value::Object(object))
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub(in crate::runtime) fn structured_to_json(
-    value: StructuredValue,
-) -> MustardResult<serde_json::Value> {
-    Ok(match value {
-        StructuredValue::Undefined => serde_json::Value::Null,
-        StructuredValue::Null => serde_json::Value::Null,
-        StructuredValue::Hole => {
-            return Err(MustardError::runtime(
-                "array holes cannot appear outside structured arrays",
-            ));
-        }
-        StructuredValue::Bool(value) => serde_json::Value::Bool(value),
-        StructuredValue::String(value) => serde_json::Value::String(value),
-        StructuredValue::Number(number) => match number {
-            StructuredNumber::Finite(value) => serde_json::Number::from_f64(value)
-                .map(serde_json::Value::Number)
-                .unwrap_or(serde_json::Value::Null),
-            StructuredNumber::NaN
-            | StructuredNumber::Infinity
-            | StructuredNumber::NegInfinity
-            | StructuredNumber::NegZero => serde_json::Value::Null,
-        },
-        StructuredValue::Array(values) => serde_json::Value::Array(
-            values
-                .into_iter()
-                .map(structured_to_json)
-                .collect::<MustardResult<Vec<_>>>()?,
-        ),
-        StructuredValue::Object(values) => serde_json::Value::Object(
-            values
-                .into_iter()
-                .map(|(key, value)| Ok((key, structured_to_json(value)?)))
-                .collect::<MustardResult<serde_json::Map<_, _>>>()?,
-        ),
-    })
-}
-
-fn structured_boundary_cycle_error() -> MustardError {
-    MustardError::runtime("cyclic values cannot cross the structured host boundary")
-}
-
-fn structured_boundary_shared_reference_error() -> MustardError {
-    MustardError::runtime("shared references cannot cross the structured host boundary")
-}
-
-fn structured_boundary_depth_error() -> MustardError {
-    MustardError::runtime("structured host boundary nesting limit exceeded")
-}
-
-fn json_value_depth_error() -> MustardError {
-    MustardError::runtime("JSON value nesting limit exceeded")
-}
-
-fn ensure_nested_depth(
-    depth: usize,
-    make_error: impl FnOnce() -> MustardError,
-) -> MustardResult<()> {
-    if depth > STRUCTURED_BOUNDARY_MAX_DEPTH {
-        return Err(make_error());
-    }
-    Ok(())
-}

package/crates/mustard/src/runtime/conversions/coercions.rs

@@ -1,217 +0,0 @@
-use super::*;
-
-impl Runtime {
-    pub(in crate::runtime) fn to_number(&self, value: Value) -> MustardResult<f64> {
-        Ok(match value {
-            Value::Undefined => f64::NAN,
-            Value::Null => 0.0,
-            Value::Bool(value) => {
-                if value {
-                    1.0
-                } else {
-                    0.0
-                }
-            }
-            Value::Number(value) => value,
-            Value::BigInt(_) => {
-                return Err(MustardError::runtime(
-                    "TypeError: cannot coerce BigInt values to numbers",
-                ));
-            }
-            Value::String(value) => value.parse::<f64>().unwrap_or(f64::NAN),
-            Value::Object(object) => match &self
-                .objects
-                .get(object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .kind
-            {
-                ObjectKind::NumberObject(value) => *value,
-                ObjectKind::StringObject(value) => value.parse::<f64>().unwrap_or(f64::NAN),
-                ObjectKind::BooleanObject(value) => {
-                    if *value {
-                        1.0
-                    } else {
-                        0.0
-                    }
-                }
-                _ => {
-                    return Err(MustardError::runtime(
-                        "cannot coerce complex value to number",
-                    ));
-                }
-            },
-            Value::Array(_)
-            | Value::Map(_)
-            | Value::Set(_)
-            | Value::Iterator(_)
-            | Value::Promise(_)
-            | Value::Closure(_)
-            | Value::BuiltinFunction(_)
-            | Value::HostFunction(_) => {
-                return Err(MustardError::runtime(
-                    "cannot coerce complex value to number",
-                ));
-            }
-        })
-    }
-
-    pub(in crate::runtime) fn to_integer(&self, value: Value) -> MustardResult<i64> {
-        let number = self.to_number(value)?;
-        if number.is_nan() || number == 0.0 {
-            Ok(0)
-        } else if number.is_infinite() {
-            Ok(if number.is_sign_positive() {
-                i64::MAX
-            } else {
-                i64::MIN
-            })
-        } else {
-            let truncated = number.trunc();
-            if truncated >= i64::MAX as f64 {
-                Ok(i64::MAX)
-            } else if truncated <= i64::MIN as f64 {
-                Ok(i64::MIN)
-            } else {
-                Ok(truncated as i64)
-            }
-        }
-    }
-
-    pub(in crate::runtime) fn to_string(&self, value: Value) -> MustardResult<String> {
-        Ok(match value {
-            Value::Undefined => "undefined".to_string(),
-            Value::Null => "null".to_string(),
-            Value::Bool(value) => value.to_string(),
-            Value::Number(value) => {
-                if value.fract() == 0.0 {
-                    format!("{}", value as i64)
-                } else {
-                    value.to_string()
-                }
-            }
-            Value::BigInt(value) => value.to_string(),
-            Value::String(value) => value,
-            Value::Array(array) => {
-                let array = self
-                    .arrays
-                    .get(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?;
-                let mut parts = Vec::new();
-                for value in &array.elements {
-                    parts.push(match value {
-                        None | Some(Value::Undefined) | Some(Value::Null) => String::new(),
-                        Some(value) => self.to_string(value.clone())?,
-                    });
-                }
-                parts.join(",")
-            }
-            Value::Map(_) => "[object Map]".to_string(),
-            Value::Set(_) => "[object Set]".to_string(),
-            Value::Object(object) => match &self
-                .objects
-                .get(object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .kind
-            {
-                ObjectKind::Date(_) => "[object Date]".to_string(),
-                ObjectKind::RegExp(regex) => format!("/{}/{}", regex.pattern, regex.flags),
-                ObjectKind::NumberObject(value) => {
-                    if value.fract() == 0.0 {
-                        format!("{}", *value as i64)
-                    } else {
-                        value.to_string()
-                    }
-                }
-                ObjectKind::StringObject(value) => value.clone(),
-                ObjectKind::BooleanObject(value) => value.to_string(),
-                ObjectKind::BoundFunction(_) => {
-                    self.callable_display_string(&Value::Object(object))?
-                }
-                _ => self
-                    .error_summary(object)?
-                    .unwrap_or_else(|| "[object Object]".to_string()),
-            },
-            Value::Iterator(_) => "[object Iterator]".to_string(),
-            Value::Promise(_) => "[object Promise]".to_string(),
-            callable @ (Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_)) => {
-                self.callable_display_string(&callable)?
-            }
-        })
-    }
-
-    pub(in crate::runtime) fn to_property_key(&self, value: Value) -> MustardResult<String> {
-        match value {
-            Value::String(value) => Ok(value),
-            Value::Number(value) => Ok(format_number_key(value)),
-            Value::BigInt(value) => Ok(value.to_string()),
-            Value::Bool(value) => Ok(value.to_string()),
-            Value::Null => Ok("null".to_string()),
-            Value::Undefined => Ok("undefined".to_string()),
-            _ => self.to_string(value),
-        }
-    }
-
-    pub(in crate::runtime) fn to_array_items(&self, value: Value) -> MustardResult<Vec<Value>> {
-        match value {
-            Value::Array(array) => self
-                .arrays
-                .get(array)
-                .map(|array| {
-                    array
-                        .elements
-                        .iter()
-                        .map(|value| value.clone().unwrap_or(Value::Undefined))
-                        .collect()
-                })
-                .ok_or_else(|| MustardError::runtime("array missing")),
-            Value::Undefined | Value::Null => Ok(Vec::new()),
-            _ => Err(MustardError::runtime(
-                "value is not destructurable as an array",
-            )),
-        }
-    }
-
-    fn callable_display_string(&self, value: &Value) -> MustardResult<String> {
-        Ok(match value {
-            Value::Closure(closure) => {
-                let closure = self
-                    .closures
-                    .get(*closure)
-                    .ok_or_else(|| MustardError::runtime("closure missing"))?;
-                let function = self
-                    .program
-                    .functions
-                    .get(closure.function_id)
-                    .ok_or_else(|| MustardError::runtime("function not found"))?;
-                if function.display_source.is_empty() {
-                    let name = self.callable_name(value)?;
-                    if name.is_empty() {
-                        "function () { [mustard code] }".to_string()
-                    } else {
-                        format!("function {name}() {{ [mustard code] }}")
-                    }
-                } else {
-                    function.display_source.clone()
-                }
-            }
-            Value::BuiltinFunction(function) => {
-                format!(
-                    "function {}() {{ [native code] }}",
-                    self.callable_name(&Value::BuiltinFunction(*function))?
-                )
-            }
-            Value::HostFunction(_) => "function () { [host code] }".to_string(),
-            Value::Object(object) => {
-                let object = self
-                    .objects
-                    .get(*object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?;
-                match object.kind {
-                    ObjectKind::BoundFunction(_) => "function () { [native code] }".to_string(),
-                    _ => "[object Object]".to_string(),
-                }
-            }
-            _ => self.to_string(value.clone())?,
-        })
-    }
-}

package/crates/mustard/src/runtime/conversions/errors.rs

@@ -1,118 +0,0 @@
-use super::*;
-
-impl Runtime {
-    pub(in crate::runtime) fn make_error_object(
-        &mut self,
-        name: &str,
-        args: &[Value],
-        code: Option<String>,
-        details: Option<Value>,
-        cause: Option<Option<Value>>,
-    ) -> MustardResult<Value> {
-        let message = match args.first() {
-            Some(Value::Undefined) | None => String::new(),
-            Some(value) => self.to_string(value.clone())?,
-        };
-        let mut properties = IndexMap::from([
-            ("name".to_string(), Value::String(name.to_string())),
-            ("message".to_string(), Value::String(message)),
-        ]);
-        if let Some(code) = code {
-            properties.insert("code".to_string(), Value::String(code));
-        }
-        if let Some(details) = details {
-            properties.insert("details".to_string(), details);
-        }
-        if let Some(cause) = cause {
-            properties.insert("cause".to_string(), cause.unwrap_or(Value::Undefined));
-        }
-        let object = self.insert_object(properties, ObjectKind::Error(name.to_string()))?;
-        Ok(Value::Object(object))
-    }
-
-    pub(in crate::runtime) fn value_from_runtime_message(
-        &mut self,
-        message: &str,
-    ) -> MustardResult<Value> {
-        let (name, detail) = match message.split_once(": ") {
-            Some((name, detail)) if name == "Error" || name.ends_with("Error") => {
-                (name.to_string(), detail.to_string())
-            }
-            _ => ("Error".to_string(), message.to_string()),
-        };
-        self.make_error_object(&name, &[Value::String(detail)], None, None, None)
-    }
-
-    pub(in crate::runtime) fn value_from_host_error(
-        &mut self,
-        error: HostError,
-    ) -> MustardResult<Value> {
-        let details = match error.details {
-            Some(details) => Some(self.value_from_structured(details)?),
-            None => None,
-        };
-        self.make_error_object(
-            &error.name,
-            &[Value::String(error.message)],
-            error.code,
-            details,
-            None,
-        )
-    }
-
-    pub(in crate::runtime) fn render_exception(&self, value: &Value) -> MustardResult<String> {
-        match value {
-            Value::Object(object) => {
-                if let Some(summary) = self.error_summary(*object)? {
-                    Ok(summary)
-                } else {
-                    self.to_string(value.clone())
-                }
-            }
-            _ => self.to_string(value.clone()),
-        }
-    }
-
-    pub(in crate::runtime) fn error_summary(
-        &self,
-        object: ObjectKey,
-    ) -> MustardResult<Option<String>> {
-        let object = self
-            .objects
-            .get(object)
-            .ok_or_else(|| MustardError::runtime("object missing"))?;
-        let details = object.properties.get("details").cloned();
-        let name = object.properties.get("name").and_then(|value| match value {
-            Value::String(value) => Some(value.as_str()),
-            _ => None,
-        });
-        let message = object
-            .properties
-            .get("message")
-            .and_then(|value| match value {
-                Value::String(value) => Some(value.as_str()),
-                _ => None,
-            });
-
-        if !matches!(object.kind, ObjectKind::Error(_)) && name.is_none() && message.is_none() {
-            return Ok(None);
-        }
-
-        let mut summary = match (name, message) {
-            (Some(name), Some("")) => name.to_string(),
-            (Some(name), Some(message)) => format!("{name}: {message}"),
-            (Some(name), None) => name.to_string(),
-            (None, Some(message)) => message.to_string(),
-            (None, None) => "Error".to_string(),
-        };
-
-        if let Some(Value::String(code)) = object.properties.get("code") {
-            summary.push_str(&format!(" [code={code}]"));
-        }
-        if let Some(details) = details {
-            summary.push_str(&format!(" [details={}]", self.to_string(details)?));
-        }
-
-        Ok(Some(summary))
-    }
-}

package/crates/mustard/src/runtime/conversions/mod.rs

@@ -1,14 +0,0 @@
-use std::collections::HashSet;
-
-use num_bigint::BigInt;
-use num_traits::{ToPrimitive, Zero};
-
-use super::*;
-
-mod boundary;
-mod coercions;
-mod errors;
-mod operators;
-
-#[allow(unused_imports)]
-pub(super) use boundary::structured_to_json;