boabem 0.1.0__tar.gz → 0.2.0__tar.gz

{boabem-0.1.0 → boabem-0.2.0}/Cargo.lock

@@ -31,9 +31,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bitflags"
-version = "2.9.2"
+version = "2.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29"
+checksum = "34efbcccd345379ca2868b2b2c9d3782e9cc58ba87bc7d79d5b53d9c9ae6f25d"
 
 [[package]]
 name = "boa_ast"
@@ -244,7 +244,7 @@ dependencies = [
 
 [[package]]
 name = "boabem"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "boa_engine",
  "boa_runtime",
@@ -976,9 +976,9 @@ checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "f2481980430f9f78649238835720ddccc57e52df14ffce1c6f37391d61b563e9"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.5",
@@ -1729,13 +1729,14 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "url"
-version = "2.5.6"
+version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "137a3c834eaf7139b73688502f3f1141a0337c5d8e4d9b536f9b8c796e26a7c4"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
 dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
+ "serde",
 ]
 
 [[package]]
@@ -1949,9 +1950,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.7.12"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]

{boabem-0.1.0 → boabem-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "boabem"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python bindings for the Rust crate 'boa', an embeddable JavaScript engine"
 edition = "2024"
 authors = ["Dowon <ks2515@naver.com>"]

{boabem-0.1.0 → boabem-0.2.0}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: boabem
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: JavaScript
 Requires-Dist: hypothesis[pytest] ; extra == 'test'
 Requires-Dist: pytest-pretty ; extra == 'test'
+Requires-Dist: json-five ; extra == 'test'
+Requires-Dist: deepdiff ; extra == 'test'
 Provides-Extra: test
 License-File: LICENSE-APACHE
 License-File: LICENSE-MIT
@@ -60,6 +62,8 @@ result = ctx.eval_from_filepath(Path("script.js"))
   - eval(source: str) -> Any
   - eval_from_bytes(source: str) -> Any (same behavior as eval)
   - eval_from_filepath(path: str | os.PathLike[str]) -> Any
+- boabem.PanicException
+  - Exception class exposed for Rust panics (e.g., attempting to use a Context across threads).
 - boabem.Undefined
   - Sentinel type representing JavaScript `undefined`.
   - String representation: "Undefined".
@@ -82,6 +86,22 @@ Notes:
 - Some JS values (e.g., Symbol) cannot be converted and will raise an error.
 - Each `undefined` you get back is a distinct Python object, but compares equal to another `Undefined`.
 
+### Object/Array conversion details
+
+When converting composite values (JavaScript Objects and Arrays) to Python `dict`/`list`, elements are converted recursively with a few caveats:
+
+- BigInt inside Objects/Arrays is converted to Python `int`.
+  - Examples: `({ a: 1n, 1: 2n, 2n: 3n }) -> {"a": 1, "1": 2, "2": 3}` and `[1, 2, 3n] -> [1, 2, 3]`.
+- `NaN` and `±Infinity` inside Objects/Arrays are preserved as Python floats (`float('nan')` / `float('inf')`).
+  - Examples: `({ a: NaN, b: Infinity }) -> {"a": nan, "b": inf}` and `[1, 2, NaN, Infinity] -> [1, 2, nan, inf]`.
+- `undefined` inside Objects/Arrays is converted to `boabem.Undefined`.
+
+Additional notes:
+
+- JavaScript object property keys are coerced to strings during conversion; for example, a `2n` property name becomes the Python key `"2"`.
+
+Note: Top-level primitives are still mapped as documented above (e.g., `10n` -> `int`, `NaN`/`Infinity` -> `float('nan')`/`float('inf')`). The special rules here apply only to values nested within Objects/Arrays.
+
 ## Threading and processes
 
 Context is not thread-sendable or picklable:
@@ -90,6 +110,8 @@ Context is not thread-sendable or picklable:
 - Do not send a Context to another process (cannot pickle).
 - Create and use a Context only in the thread where it was created.
 
+If you try to use a Context across threads, you'll get a Rust panic surfaced as `pyo3_runtime.PanicException` (exposed as `boabem.PanicException`).
+
 ## Errors
 
 - JavaScript exceptions (e.g., `throw new Error('boom')`) raise RuntimeError with the JS message.

{boabem-0.1.0 → boabem-0.2.0}/README.md

@@ -42,6 +42,8 @@ result = ctx.eval_from_filepath(Path("script.js"))
   - eval(source: str) -> Any
   - eval_from_bytes(source: str) -> Any (same behavior as eval)
   - eval_from_filepath(path: str | os.PathLike[str]) -> Any
+- boabem.PanicException
+  - Exception class exposed for Rust panics (e.g., attempting to use a Context across threads).
 - boabem.Undefined
   - Sentinel type representing JavaScript `undefined`.
   - String representation: "Undefined".
@@ -64,6 +66,22 @@ Notes:
 - Some JS values (e.g., Symbol) cannot be converted and will raise an error.
 - Each `undefined` you get back is a distinct Python object, but compares equal to another `Undefined`.
 
+### Object/Array conversion details
+
+When converting composite values (JavaScript Objects and Arrays) to Python `dict`/`list`, elements are converted recursively with a few caveats:
+
+- BigInt inside Objects/Arrays is converted to Python `int`.
+  - Examples: `({ a: 1n, 1: 2n, 2n: 3n }) -> {"a": 1, "1": 2, "2": 3}` and `[1, 2, 3n] -> [1, 2, 3]`.
+- `NaN` and `±Infinity` inside Objects/Arrays are preserved as Python floats (`float('nan')` / `float('inf')`).
+  - Examples: `({ a: NaN, b: Infinity }) -> {"a": nan, "b": inf}` and `[1, 2, NaN, Infinity] -> [1, 2, nan, inf]`.
+- `undefined` inside Objects/Arrays is converted to `boabem.Undefined`.
+
+Additional notes:
+
+- JavaScript object property keys are coerced to strings during conversion; for example, a `2n` property name becomes the Python key `"2"`.
+
+Note: Top-level primitives are still mapped as documented above (e.g., `10n` -> `int`, `NaN`/`Infinity` -> `float('nan')`/`float('inf')`). The special rules here apply only to values nested within Objects/Arrays.
+
 ## Threading and processes
 
 Context is not thread-sendable or picklable:
@@ -72,6 +90,8 @@ Context is not thread-sendable or picklable:
 - Do not send a Context to another process (cannot pickle).
 - Create and use a Context only in the thread where it was created.
 
+If you try to use a Context across threads, you'll get a Rust panic surfaced as `pyo3_runtime.PanicException` (exposed as `boabem.PanicException`).
+
 ## Errors
 
 - JavaScript exceptions (e.g., `throw new Error('boom')`) raise RuntimeError with the JS message.

{boabem-0.1.0 → boabem-0.2.0}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-test = ["hypothesis[pytest]", "pytest-pretty"]
+test = ["hypothesis[pytest]", "pytest-pretty", "json-five", "deepdiff"]
 
 [project.urls]
 source = "https://github.com/Bing-su/boabem"

boabem-0.2.0/python/boabem/__init__.py

@@ -0,0 +1,3 @@
+from .boabem import Context, PanicException, Undefined, __version__
+
+__all__ = ["Context", "PanicException", "Undefined", "__version__"]

{boabem-0.1.0 → boabem-0.2.0}/python/boabem/boabem.pyi

@@ -4,9 +4,9 @@ from typing import Any
 __version__: str
 
 class Context:
-    def __init__(self): ...
     def eval(self, source: str) -> Any: ...
     def eval_from_bytes(self, source: str) -> Any: ...
     def eval_from_filepath(self, source: str | os.PathLike[str]) -> Any: ...
 
 class Undefined: ...
+class PanicException(BaseException): ...

{boabem-0.1.0 → boabem-0.2.0}/src/hebi.rs

@@ -1,7 +1,11 @@
+use boa_engine::value::TryFromJs;
 use boa_engine::{Context, JsValue, Source};
 use eyre::{Result, eyre};
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList};
 use pythonize::pythonize;
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[pyclass(name = "Undefined", module = "boabem.boabem", str, eq, frozen)]
@@ -11,8 +15,8 @@ pub struct PyUndefined {}
 #[pymethods]
 impl PyUndefined {
     #[new]
-    fn new() -> Self {
-        PyUndefined {}
+    fn py_new() -> Self {
+        Self::new()
     }
 
     fn __repr__(&self) -> &str {
@@ -20,6 +24,12 @@ impl PyUndefined {
     }
 }
 
+impl PyUndefined {
+    fn new() -> Self {
+        Self {}
+    }
+}
+
 impl std::fmt::Display for PyUndefined {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "undefined")
@@ -65,7 +75,7 @@ impl PyContext {
     }
 }
 
-fn pybigint(value: &str) -> Result<PyObject> {
+fn to_pybigint(value: &str) -> Result<PyObject> {
     Python::with_gil(|py| {
         let builtins = PyModule::import(py, "builtins")?;
         let int_class = builtins.getattr("int")?;
@@ -74,24 +84,21 @@ fn pybigint(value: &str) -> Result<PyObject> {
     })
 }
 
-fn pyfloat(value: f64) -> Result<PyObject> {
-    Python::with_gil(|py| {
-        let pyfloat = value.into_pyobject(py)?;
-        Ok(pyfloat.into())
-    })
+fn to_pyobject<'a, T: IntoPyObjectExt<'a>>(py: Python<'a>, value: T) -> Result<PyObject> {
+    Ok(value.into_py_any(py)?)
 }
 
 impl PyContext {
     fn jsvalue_to_pyobject(&mut self, value: JsValue) -> Result<PyObject> {
         match value {
-            JsValue::Undefined => {
-                Python::with_gil(|py| Ok(Py::new(py, PyUndefined::new())?.into_any()))
-            }
+            JsValue::Undefined => Python::with_gil(|py| to_pyobject(py, PyUndefined::new())),
             JsValue::BigInt(js_bigint) => {
                 let bigint_str = js_bigint.to_string_radix(10);
-                pybigint(&bigint_str)
+                to_pybigint(&bigint_str)
             }
-            JsValue::Rational(f) => pyfloat(f),
+            JsValue::Rational(v) => Python::with_gil(|py| to_pyobject(py, v)),
+            JsValue::Object(obj) if obj.is_array() => self.jsobj_to_py_list(&JsValue::Object(obj)),
+            JsValue::Object(obj) => self.jsobj_to_py_dict(&JsValue::Object(obj)),
             other => {
                 let json = other
                     .to_json(&mut self.context)
@@ -104,4 +111,32 @@ impl PyContext {
             }
         }
     }
+
+    fn jsobj_to_py_list(&mut self, obj: &JsValue) -> Result<PyObject> {
+        let arr: Vec<JsValue> =
+            Vec::try_from_js(obj, &mut self.context).map_err(|e| eyre!(e.to_string()))?;
+
+        Python::with_gil(|py| {
+            let py_list = PyList::empty(py);
+            for item in arr {
+                let py_item = self.jsvalue_to_pyobject(item)?;
+                py_list.append(py_item)?;
+            }
+            Ok(py_list.into())
+        })
+    }
+
+    fn jsobj_to_py_dict(&mut self, obj: &JsValue) -> Result<PyObject> {
+        let map: HashMap<String, JsValue> =
+            HashMap::try_from_js(obj, &mut self.context).map_err(|e| eyre!(e.to_string()))?;
+
+        Python::with_gil(|py| {
+            let py_dict = PyDict::new(py);
+            for (key, value) in map {
+                let py_value = self.jsvalue_to_pyobject(value)?;
+                py_dict.set_item(key, py_value)?;
+            }
+            Ok(py_dict.into())
+        })
+    }
 }

{boabem-0.1.0 → boabem-0.2.0}/src/lib.rs

@@ -1,10 +1,12 @@
+use pyo3::panic::PanicException;
 use pyo3::prelude::*;
 mod hebi;
 
 #[pymodule]
-fn boabem(m: &Bound<'_, PyModule>) -> PyResult<()> {
+fn boabem(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     m.add_class::<hebi::PyUndefined>()?;
     m.add_class::<hebi::PyContext>()?;
+    m.add("PanicException", py.get_type::<PanicException>())?;
     Ok(())
 }

boabem-0.2.0/tests/conversion_test.py

@@ -0,0 +1,155 @@
+import sys
+from math import isnan
+from typing import Any
+
+import json5
+import pytest
+from deepdiff import DeepDiff
+from hypothesis import given
+from hypothesis import strategies as st
+
+from boabem import Context, Undefined
+
+
+def json(*, finite_only: bool = True):
+    """Helper function to describe JSON objects, with optional inf and nan."""
+    numbers = st.floats(allow_infinity=not finite_only, allow_nan=not finite_only)
+    return st.recursive(
+        st.none() | st.booleans() | st.integers() | numbers | st.text(),
+        extend=lambda xs: st.lists(xs) | st.dictionaries(st.text(), xs),
+    )
+
+
+def json_array(*, finite_only: bool = True):
+    return st.lists(json(finite_only=finite_only))
+
+
+def json_object(*, finite_only: bool = True):
+    return st.dictionaries(st.text(), json(finite_only=finite_only))
+
+
+@given(value=st.integers(min_value=-(10**9), max_value=10**9))
+def test_int(value: int):
+    ctx = Context()
+    code = str(value)
+    assert ctx.eval(code) == value
+
+
+@given(value=st.floats(allow_infinity=True, allow_nan=True))
+def test_float(value: float):
+    ctx = Context()
+    code = json5.dumps(value).replace("nan", "NaN")
+    result = ctx.eval(code)
+    assert value == result or (isnan(value) and isnan(result))
+
+
+@given(value=st.integers(min_value=-(10**100), max_value=10**100))
+def test_bigint(value: int):
+    ctx = Context()
+    code = f"{value}n"
+    assert ctx.eval(code) == value
+
+
+@given(value=json_array(finite_only=False))
+def test_json_array(value: list[Any]):
+    ctx = Context()
+    code = json5.dumps(value).replace("nan", "NaN")
+    result = ctx.eval(f"let arr = {code};\narr")
+    assert isinstance(result, list)
+
+    diff = DeepDiff(
+        value, result, ignore_nan_inequality=True, ignore_numeric_type_changes=True
+    )
+    assert len(diff.affected_paths) == 0
+
+
+@given(value=json_object(finite_only=False))
+def test_json_object(value: dict[str, Any]):
+    ctx = Context()
+    code = json5.dumps(value).replace("nan", "NaN")
+    result = ctx.eval(f"let obj = {code};\nobj")
+    assert isinstance(result, dict)
+
+    diff = DeepDiff(
+        value, result, ignore_nan_inequality=True, ignore_numeric_type_changes=True
+    )
+    assert len(diff.affected_paths) == 0
+
+
+@given(value=json(finite_only=False))
+def test_any_json(value: Any):
+    ctx = Context()
+    code = json5.dumps(value).replace("nan", "NaN")
+    result = ctx.eval(f"let obj = {code};\nobj")
+    diff = DeepDiff(
+        value, result, ignore_nan_inequality=True, ignore_numeric_type_changes=True
+    )
+    assert len(diff.affected_paths) == 0
+
+
+def test_deep_object():
+    ctx = Context()
+    code = """
+let obj = {a:{b:{c:{d:{e:{f:{g:{h:{i:{j:1}}}}}}}}}};
+obj
+"""
+    result = ctx.eval(code)
+    diff = DeepDiff(result, json5.loads("{a:{b:{c:{d:{e:{f:{g:{h:{i:{j:1}}}}}}}}}}"))
+    assert len(diff.affected_paths) == 0
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="https://docs.python.org/3.13/library/stdtypes.html#integer-string-conversion-length-limitation",
+)
+def test_integer_string_conversion_length_limitation():
+    ctx = Context()
+    code = "10n ** 4300n"
+    with pytest.raises(ValueError, match="Exceeds the limit"):
+        ctx.eval(code)
+
+
+def test_bigint_in_object():
+    ctx = Context()
+    assert ctx.eval("({ a: 1n, 1: 2n, 2n: 3n })") == {"a": 1, "1": 2, "2": 3}
+    assert ctx.eval("[1, 2, 3n]") == [1, 2, 3]
+
+
+def test_nan_inf_in_object():
+    ctx = Context()
+    result = ctx.eval(
+        "({ a: NaN, b: Infinity, NaN: NaN, Infinity: Infinity, null: null })"
+    )
+    assert isinstance(result, dict)
+    assert result == pytest.approx(
+        {
+            "a": float("nan"),
+            "b": float("inf"),
+            "NaN": float("nan"),
+            "Infinity": float("inf"),
+            "null": None,
+        },
+        nan_ok=True,
+    )
+
+    result = ctx.eval("[1, 2, NaN, Infinity]")
+    assert isinstance(result, list)
+    assert result == pytest.approx([1, 2, float("nan"), float("inf")], nan_ok=True)
+
+
+def test_undefined_in_object():
+    ctx = Context()
+    assert ctx.eval("({ a: undefined, undefined: undefined })") == {
+        "a": Undefined(),
+        "undefined": Undefined(),
+    }
+    assert ctx.eval("[1, 2, undefined]") == [1, 2, Undefined()]
+
+
+def test_function():
+    ctx = Context()
+    code = """
+let test_add = (a, b) => a + b;
+test_add
+"""
+    assert ctx.eval(code) == {"length": 2, "name": "test_add"}

{boabem-0.1.0 → boabem-0.2.0}/tests/main_test.py

@@ -1,5 +1,4 @@
 import json
-import sys
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 from math import isinf, isnan
 from pathlib import Path
@@ -7,7 +6,7 @@ from typing import Any
 
 import pytest
 
-from boabem import Context, Undefined
+from boabem import Context, PanicException, Undefined
 
 
 def test_banana():
@@ -393,7 +392,7 @@ def test_thread_pool():
         future = executor.submit(ctx.eval, "1 + 1")
 
     # pyo3_runtime.PanicException
-    with pytest.raises(BaseException, match="unsendable"):
+    with pytest.raises(PanicException, match="unsendable"):
         future.result()
 
 
@@ -404,14 +403,3 @@ def test_process_pool():
 
     with pytest.raises(TypeError, match="cannot pickle"):
         future.result()
-
-
-@pytest.mark.skipif(
-    sys.version_info < (3, 11),
-    reason="https://docs.python.org/3.13/library/stdtypes.html#integer-string-conversion-length-limitation",
-)
-def test_integer_string_conversion_length_limitation():
-    ctx = Context()
-    code = "10n ** 4300n"
-    with pytest.raises(ValueError, match="Exceeds the limit"):
-        ctx.eval(code)

boabem-0.1.0/python/boabem/__init__.py

@@ -1,3 +0,0 @@
-from .boabem import Context, Undefined, __version__
-
-__all__ = ["Context", "Undefined", "__version__"]