github
/
boa
mirror of https://github.com/boa-dev/boa.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Implementation of JsMap Wrapper (#2115) 

<!---
Thank you for contributing to Boa! Please fill out the template below, and remove or add any
information as you feel neccessary.
--->

This Pull Request related to JsMap for #2098.

Any feedback on implementing JsMapIterator would be welcome. I wasn't entirely sure if it was the right approach, but as I worked on the example file, it felt like something at least similar would be needed to use Map's .entries(), .keys(), and .values() methods.

It changes the following:

- Implements JsMap Wrapper
- Implements JsMapIterator Wrapper
- Creates JsMap example in boa_examples
pull/2168/head
Kevin 2 years ago
parent
36f93a5380
commit
d0d70345eb
5 changed files with 557 additions and 1 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 426
      boa_engine/src/object/jsmap.rs
  2. 57
      boa_engine/src/object/jsmap_iterator.rs
  3. 13
      boa_engine/src/object/jsobject.rs
  4. 4
      boa_engine/src/object/mod.rs
  5. 58
      boa_examples/src/bin/jsmap.rs

426
boa_engine/src/object/jsmap.rs
Unescape View File

@ -0,0 +1,426 @@
//! This module implements a wrapper for the Map Builtin Javascript Object
use crate::{
builtins::map::{add_entries_from_iterable, ordered_map::OrderedMap},
builtins::Map,
object::{JsFunction, JsMapIterator, JsObject, JsObjectType, ObjectData},
Context, JsResult, JsValue,
};
use boa_gc::{Finalize, Trace};
use std::ops::Deref;
/// `JsMap` provides a wrapper for Boa's implementation of the Javascript `Map` object.
///
/// # Examples
///
/// Create a `JsMap` and set a new entry
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// // Create default `Context`
/// let context = &mut Context::default();
///
/// // Create a new empty `JsMap`.
/// let map = JsMap::new(context);
///
/// // Set key-value pairs for the `JsMap`.
/// map.set("Key-1", "Value-1", context).unwrap();
/// map.set("Key-2", 10, context).unwrap();
///
/// assert_eq!(map.get_size(context).unwrap(), 2.into());
///
/// ```
///
/// Create a `JsMap` from a `JsArray`
/// ```
/// # use boa_engine::{
/// # object::{JsArray, JsMap},
/// # Context, JsValue,
/// # };
///
/// // Create a default `Context`
/// let context = &mut Context::default();
///
/// // Create an array of two `[key, value]` pairs
/// let js_array = JsArray::new(context);
///
/// // Create a `[key, value]` pair of JsValues
/// let vec_one: Vec<JsValue> = vec![JsValue::new("first-key"), JsValue::new("first-value")];
///
/// // We create an push our `[key, value]` pair onto our array as a `JsArray`
/// js_array.push(JsArray::from_iter(vec_one, context), context).unwrap();
///
/// // Create a `JsMap` from the `JsArray` using it's iterable property.
/// let js_iterable_map = JsMap::from_js_iterable(&js_array.into(), context).unwrap();
///
/// assert_eq!(js_iterable_map.get("first-key", context).unwrap(), "first-value".into());
///
/// ```
///
#[derive(Debug, Clone, Trace, Finalize)]
pub struct JsMap {
inner: JsObject,
}
impl JsMap {
/// Creates a new empty [`JsMap`] object.
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// // Create a new context.
/// let context = &mut Context::default();
///
/// // Create a new empty `JsMap`.
/// let map = JsMap::new(context);
///
/// ```
#[inline]
pub fn new(context: &mut Context) -> Self {
let map = Self::create_map(context);
Self { inner: map }
}
/// Create a new [`JsMap`] object from a [`JsObject`] that has an `@@Iterator` field.
///
/// # Examples
/// ```
/// # use boa_engine::{
/// # object::{JsArray, JsMap},
/// # Context, JsResult, JsValue,
/// # };
///
/// // Create a default `Context`
/// let context = &mut Context::default();
///
/// // Create an array of two `[key, value]` pairs
/// let js_array = JsArray::new(context);
///
/// // Create a `[key, value]` pair of JsValues and add it to the `JsArray` as a `JsArray`
/// let vec_one: Vec<JsValue> = vec![JsValue::new("first-key"), JsValue::new("first-value")];
/// js_array.push(JsArray::from_iter(vec_one, context), context).unwrap();
///
/// // Create a `JsMap` from the `JsArray` using it's iterable property.
/// let js_iterable_map = JsMap::from_js_iterable(&js_array.into(), context).unwrap();
///
/// ```
///
#[inline]
pub fn from_js_iterable(iterable: &JsValue, context: &mut Context) -> JsResult<Self> {
// Create a new map object.
let map = Self::create_map(context);
// Let adder be Get(map, "set") per spec. This action should not fail with default map.
let adder = map
.get("set", context)
.expect("creating a map with the default prototype must not fail");
let _completion_record = add_entries_from_iterable(&map, iterable, &adder, context)?;
Ok(Self { inner: map })
}
/// Creates a [`JsMap`] from a valid [`JsObject`], or returns a `TypeError` if the provided object is not a [`JsMap`]
///
/// # Examples
///
/// Valid Example - returns a `JsMap` object
/// ```
/// # use boa_engine::{
/// # builtins::map::ordered_map::OrderedMap,
/// # object::{JsObject, ObjectData, JsMap},
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// // `some_object` can be any JavaScript `Map` object.
/// let some_object = JsObject::from_proto_and_data(
/// context.intrinsics().constructors().map().prototype(),
/// ObjectData::map(OrderedMap::new())
/// );
///
/// // Create `JsMap` object with incoming object.
/// let js_map = JsMap::from_object(some_object, context).unwrap();
///
/// ```
///
/// Invalid Example - returns a `TypeError` with the message "object is not a Map"
/// ```
/// # use boa_engine::{
/// # object::{JsObject, JsArray, JsMap},
/// # Context, JsResult, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let some_object = JsArray::new(context);
///
/// // Some object is an Array object, not a map object
/// assert!(JsMap::from_object(some_object.into(), context).is_err());
///
/// ```
#[inline]
pub fn from_object(object: JsObject, context: &mut Context) -> JsResult<Self> {
if object.borrow().is_map() {
Ok(Self { inner: object })
} else {
context.throw_type_error("object is not a Map")
}
}
// Utility function to generate the default `Map` object.
fn create_map(context: &mut Context) -> JsObject {
// Get default Map prototype
let prototype = context.intrinsics().constructors().map().prototype();
// Create a default map object with [[MapData]] as a new empty list
JsObject::from_proto_and_data(prototype, ObjectData::map(OrderedMap::new()))
}
/// Returns a new [`JsMapIterator`] object that yields the `[key, value]` pairs within the [`JsMap`] in insertion order.
#[inline]
pub fn entries(&self, context: &mut Context) -> JsResult<JsMapIterator> {
let iterator_record = Map::entries(&self.inner.clone().into(), &[], context)?
.get_iterator(context, None, None)?;
let map_iterator_object = iterator_record.iterator();
JsMapIterator::from_object(map_iterator_object.clone(), context)
}
/// Returns a new [`JsMapIterator`] object that yields the `key` for each element within the [`JsMap`] in insertion order.
#[inline]
pub fn keys(&self, context: &mut Context) -> JsResult<JsMapIterator> {
let iterator_record = Map::keys(&self.inner.clone().into(), &[], context)?
.get_iterator(context, None, None)?;
let map_iterator_object = iterator_record.iterator();
JsMapIterator::from_object(map_iterator_object.clone(), context)
}
/// Inserts a new entry into the [`JsMap`] object
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let js_map = JsMap::new(context);
///
/// js_map.set("foo", "bar", context).unwrap();
/// js_map.set(2, 4, context).unwrap();
///
/// assert_eq!(js_map.get("foo", context).unwrap(), "bar".into());
/// assert_eq!(js_map.get(2, context).unwrap(), 4.into())
///
/// ```
#[inline]
pub fn set<K, V>(&self, key: K, value: V, context: &mut Context) -> JsResult<JsValue>
where
K: Into<JsValue>,
V: Into<JsValue>,
{
Map::set(
&self.inner.clone().into(),
&[key.into(), value.into()],
context,
)
}
/// Gets the size of the [`JsMap`] object.
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let js_map = JsMap::new(context);
///
/// js_map.set("foo", "bar", context).unwrap();
///
/// let map_size = js_map.get_size(context).unwrap();
///
/// assert_eq!(map_size, 1.into());
///
/// ```
#[inline]
pub fn get_size(&self, context: &mut Context) -> JsResult<JsValue> {
Map::get_size(&self.inner.clone().into(), &[], context)
}
/// Removes element from [`JsMap`] with a matching `key` value.
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let js_map = JsMap::new(context);
/// js_map.set("foo", "bar", context).unwrap();
/// js_map.set("hello", "world", context).unwrap();
///
/// js_map.delete("foo", context).unwrap();
///
/// assert_eq!(js_map.get_size(context).unwrap(), 1.into());
/// assert_eq!(js_map.get("foo", context).unwrap(), JsValue::undefined());
///
/// ```
#[inline]
pub fn delete<T>(&self, key: T, context: &mut Context) -> JsResult<JsValue>
where
T: Into<JsValue>,
{
Map::delete(&self.inner.clone().into(), &[key.into()], context)
}
/// Gets the value associated with the specified key within the [`JsMap`], or `undefined` if the key does not exist.
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
/// let js_map = JsMap::new(context);
/// js_map.set("foo", "bar", context).unwrap();
///
/// let retrieved_value = js_map.get("foo", context).unwrap();
///
/// assert_eq!(retrieved_value, "bar".into());
///
/// ```
#[inline]
pub fn get<T>(&self, key: T, context: &mut Context) -> JsResult<JsValue>
where
T: Into<JsValue>,
{
Map::get(&self.inner.clone().into(), &[key.into()], context)
}
/// Removes all entries from the [`JsMap`].
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let js_map = JsMap::new(context);
/// js_map.set("foo", "bar", context).unwrap();
/// js_map.set("hello", "world", context).unwrap();
///
/// js_map.clear(context).unwrap();
///
/// assert_eq!(js_map.get_size(context).unwrap(), 0.into());
///
/// ```
#[inline]
pub fn clear(&self, context: &mut Context) -> JsResult<JsValue> {
Map::clear(&self.inner.clone().into(), &[], context)
}
/// Checks if [`JsMap`] has an entry with the provided `key` value.
///
/// # Example
///
/// ```
/// # use boa_engine::{
/// # object::JsMap,
/// # Context, JsValue,
/// # };
///
/// let context = &mut Context::default();
///
/// let js_map = JsMap::new(context);
/// js_map.set("foo", "bar", context).unwrap();
///
/// let has_key = js_map.has("foo", context).unwrap();
///
/// assert_eq!(has_key, true.into());
///
/// ```
#[inline]
pub fn has<T>(&self, key: T, context: &mut Context) -> JsResult<JsValue>
where
T: Into<JsValue>,
{
Map::has(&self.inner.clone().into(), &[key.into()], context)
}
/// Executes the provided callback function for each key-value pair within the [`JsMap`].
#[inline]
pub fn for_each(
&self,
callback: JsFunction,
this_arg: JsValue,
context: &mut Context,
) -> JsResult<JsValue> {
Map::for_each(
&self.inner.clone().into(),
&[callback.into(), this_arg],
context,
)
}
/// Returns a new [`JsMapIterator`] object that yields the `value` for each element within the [`JsMap`] in insertion order.
#[inline]
pub fn values(&self, context: &mut Context) -> JsResult<JsMapIterator> {
let iterator_record = Map::values(&self.inner.clone().into(), &[], context)?
.get_iterator(context, None, None)?;
let map_iterator_object = iterator_record.iterator();
JsMapIterator::from_object(map_iterator_object.clone(), context)
}
}
impl From<JsMap> for JsObject {
#[inline]
fn from(o: JsMap) -> Self {
o.inner.clone()
}
}
impl From<JsMap> for JsValue {
#[inline]
fn from(o: JsMap) -> Self {
o.inner.clone().into()
}
}
impl Deref for JsMap {
type Target = JsObject;
#[inline]
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl JsObjectType for JsMap {}

57
boa_engine/src/object/jsmap_iterator.rs
Unescape View File

@ -0,0 +1,57 @@
//! This module implements a wrapper for the `MapIterator` object
use crate::{
builtins::map::map_iterator::MapIterator,
object::{JsObject, JsObjectType},
Context, JsResult, JsValue,
};
use boa_gc::{Finalize, Trace};
use std::ops::Deref;
/// JavaScript `MapIterator` rust object
#[derive(Debug, Clone, Finalize, Trace)]
pub struct JsMapIterator {
inner: JsObject,
}
impl JsMapIterator {
/// Create a [`JsMapIterator`] from a [`JsObject`]. If object is not a `MapIterator`, throw `TypeError`
#[inline]
pub fn from_object(object: JsObject, context: &mut Context) -> JsResult<Self> {
if object.borrow().is_map_iterator() {
Ok(Self { inner: object })
} else {
context.throw_type_error("object is not a MapIterator")
}
}
/// Advances the `JsMapIterator` and gets the next result in the `JsMap`
pub fn next(&self, context: &mut Context) -> JsResult<JsValue> {
MapIterator::next(&self.inner.clone().into(), &[], context)
}
}
impl From<JsMapIterator> for JsObject {
#[inline]
fn from(o: JsMapIterator) -> Self {
o.inner.clone()
}
}
impl From<JsMapIterator> for JsValue {
#[inline]
fn from(o: JsMapIterator) -> Self {
o.inner.clone().into()
}
}
impl Deref for JsMapIterator {
type Target = JsObject;
#[inline]
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl JsObjectType for JsMapIterator {}

13
boa_engine/src/object/jsobject.rs
Unescape View File

@ -313,7 +313,7 @@ impl JsObject {
self.borrow().is_array_buffer()
}
/// Checks if it is a `Map` object.pub
/// Checks if it is a `Map` object.
///
/// # Panics
///
@ -324,6 +324,17 @@ impl JsObject {
self.borrow().is_map()
}
/// Checks if it's a `MapIterator` object
///
/// # Panics
///
/// Panics if the object is currently mutably borrowed.
#[inline]
#[track_caller]
pub fn is_map_iterator(&self) -> bool {
self.borrow().is_map_iterator()
}
/// Checks if it's a `String` object.
///
/// # Panics

4
boa_engine/src/object/mod.rs
Unescape View File

@ -63,6 +63,8 @@ mod tests;
pub(crate) mod internal_methods;
mod jsarray;
mod jsfunction;
mod jsmap;
mod jsmap_iterator;
mod jsobject;
mod jsproxy;
mod jstypedarray;
@ -71,6 +73,8 @@ mod property_map;
pub use jsarray::*;
pub use jsfunction::*;
pub use jsmap::*;
pub use jsmap_iterator::*;
pub use jsproxy::*;
pub use jstypedarray::*;

58
boa_examples/src/bin/jsmap.rs
Unescape View File

@ -0,0 +1,58 @@
use boa_engine::{
object::{JsArray, JsMap},
Context, JsResult, JsValue,
};
fn main() -> JsResult<()> {
// Create a `Context` for the Javascript executor.
let context = &mut Context::default();
// Create a new empty map.
let map = JsMap::new(context);
// Set a key-value for the map.
map.set("Key-1", "Value-1", context)?;
let map_check = map.has("Key-1", context)?;
assert_eq!(map_check, true.into()); // true
// Set a second key-value to the same map.
map.set(2, 4, context)?;
assert_eq!(map.get_size(context)?, 2.into()); //true
assert_eq!(map.get("Key-1", context)?, "Value-1".into());
assert_eq!(map.get(2, context)?, 4.into());
// Delete an entry with a provided key.
map.delete("Key-1", context)?;
assert_eq!(map.get_size(context)?, 1.into());
let deleted_key_one = map.get("Key-1", context)?;
assert_eq!(deleted_key_one, JsValue::undefined());
// Retrieve a MapIterator for all entries in the Map.
let entries = map.entries(context)?;
let _first_value = entries.next(context)?;
// Create a multidimensional array with key value pairs -> [[first-key, first-value], [second-key, second-value]]
let js_array = JsArray::new(context);
let vec_one = vec![JsValue::new("first-key"), JsValue::new("first-value")];
let vec_two = vec![JsValue::new("second-key"), JsValue::new("second-value")];
js_array.push(JsArray::from_iter(vec_one, context), context)?;
js_array.push(JsArray::from_iter(vec_two, context), context)?;
// Create a map from the JsArray using it's iterable property.
let iter_map = JsMap::from_js_iterable(&js_array.into(), context)?;
assert_eq!(iter_map.get("first-key", context)?, "first-value".into());
iter_map.set("third-key", "third-value", context)?;
assert_eq!(iter_map.get_size(context)?, JsValue::new(3));
Ok(())
}
Write Preview
Loading…
Cancel
Save