[Merged by Bors] - Added boa examples

.github/workflows/bors.yml

@@ -126,16 +126,16 @@ jobs:
             ~/.cargo/git
             ~/.cargo/registry
           key: ${{ runner.os }}-cargo-examples-${{ hashFiles('**/Cargo.lock') }}
+      - run: cd boa_examples
       - name: Build examples
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --examples -v
       - name: Run example classes
         uses: actions-rs/cargo@v1
         with:
           command: run
-          args: --example classes
+          args: --bin classes
 
   doc:
     name: Documentation

.github/workflows/rust.yml

@@ -130,16 +130,16 @@ jobs:
             ~/.cargo/git
             ~/.cargo/registry
           key: ${{ runner.os }}-cargo-examples-${{ hashFiles('**/Cargo.lock') }}
+      - run: cd boa_examples
       - name: Build examples
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --examples -v
       - name: Run example classes
         uses: actions-rs/cargo@v1
         with:
           command: run
-          args: --example classes
+          args: --bin classes
 
   doc:
     name: Documentation

Cargo.toml

@@ -8,6 +8,7 @@ members = [
     "boa_tester",
     "boa_unicode",
     "boa_wasm",
+    "boa_examples",
 ]
 
 # The release profile, used for `cargo build --release`.

boa_examples/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "boa_examples"
+version = "0.11.0"
+authors = ["boa-dev"]
+repository = "https://github.com/boa-dev/boa"
+license = "Unlicense/MIT"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+boa_engine = { path = "../boa_engine", features = ["console"] }
+boa_gc = { path = "../boa_gc" }
+gc = { version = "0.4.1" }

boa_examples/scripts/calc.js

@@ -0,0 +1,14 @@
+module.exports = {
+  add: function (a, b) {
+    return a + b;
+  },
+  subtract: function (a, b) {
+    return a - b;
+  },
+  multiply: function (a, b) {
+    return a * b;
+  },
+  divide: function (a, b) {
+    return a / b;
+  },
+};

boa_examples/scripts/calctest.js

@@ -0,0 +1,8 @@
+//load module
+let calc = require("./scripts/calc.js");
+
+console.log("Using calc module");
+console.log("Add: " + calc.add(3, 3));
+console.log("Subtract: " + calc.subtract(3, 3));
+console.log("Multiply: " + calc.multiply(3, 3));
+console.log("Divide: " + calc.divide(3, 3));

boa_examples/scripts/enhancedglobal.js

@@ -0,0 +1,11 @@
+//access custom global variable
+console.log("Custom global: " + customstring);
+
+//call a custom global function with arguments
+console.log("Custom function: " + rusty_hello("Boa! Boa!"));
+
+//access a custom global object and call a member function of that object
+let a = 5;
+let b = 5;
+let result = rusty_obj.add(a, b);
+console.log("Custom object: Result from rusty_obj.add() : " + result);

boa_examples/scripts/helloworld.js

@@ -0,0 +1 @@
+console.log("Hello World from JS file!");

boa_engine/examples/classes.rs → boa_examples/src/bin/classes.rs

@@ -1,10 +1,10 @@
 // NOTE: this example requires the `console` feature to run correctly.
-
 use boa_engine::{
     class::{Class, ClassBuilder},
     property::Attribute,
     Context, JsResult, JsValue,
 };
+
 use boa_gc::{Finalize, Trace};
 
 // We create a new struct that is going to represent a person.

boa_engine/examples/jsarray.rs → boa_examples/src/bin/jsarray.rs

@@ -1,9 +1,11 @@
+// This example shows how to manipulate a Javascript array using Rust code.
+
 use boa_engine::{
     object::{FunctionBuilder, JsArray},
-    Context, JsValue,
+    Context, JsResult, JsValue,
 };
 
-fn main() -> Result<(), JsValue> {
+fn main() -> JsResult<()> {
     // We create a new `Context` to create a new Javascript executor.
     let context = &mut Context::default();
 

boa_examples/src/bin/loadfile.rs

@@ -0,0 +1,28 @@
+// This example shows how to load, parse and execute JS code from a source file
+// (./scripts/helloworld.js)
+
+use std::fs::read_to_string;
+
+use boa_engine::Context;
+
+fn main() {
+    let js_file_path = "./scripts/helloworld.js";
+
+    match read_to_string(js_file_path) {
+        Ok(src) => {
+            // Instantiate the execution context
+            let mut context = Context::default();
+            // Parse the source code
+            match context.eval(src) {
+                Ok(res) => {
+                    println!("{}", res.to_string(&mut context).unwrap());
+                }
+                Err(e) => {
+                    // Pretty print the error
+                    eprintln!("Uncaught {}", e.display());
+                }
+            };
+        }
+        Err(msg) => eprintln!("Error: {}", msg),
+    }
+}

boa_examples/src/bin/loadstring.rs

@@ -0,0 +1,21 @@
+// This example loads, parses and executes a JS code string
+
+use boa_engine::Context;
+
+fn main() {
+    let js_code = "console.log('Hello World from a JS code string!')";
+
+    // Instantiate the execution context
+    let mut context = Context::default();
+
+    // Parse the source code
+    match context.eval(js_code) {
+        Ok(res) => {
+            println!("{}", res.to_string(&mut context).unwrap());
+        }
+        Err(e) => {
+            // Pretty print the error
+            eprintln!("Uncaught {}", e.display());
+        }
+    };
+}

boa_examples/src/bin/modulehandler.rs

@@ -0,0 +1,59 @@
+// This example implements a custom module handler which mimics
+// the require/module.exports pattern
+
+use boa_engine::{prelude::JsObject, property::Attribute, Context, JsResult, JsValue};
+use std::fs::read_to_string;
+
+fn main() {
+    let js_file_path = "./scripts/calctest.js";
+    let buffer = read_to_string(js_file_path);
+
+    if buffer.is_err() {
+        println!("Error: {}", buffer.unwrap_err());
+        return;
+    }
+
+    // Creating the execution context
+    let mut ctx = Context::default();
+
+    // Adding custom implementation that mimics 'require'
+    ctx.register_global_function("require", 0, require);
+
+    // Adding custom object that mimics 'module.exports'
+    let moduleobj = JsObject::default();
+    moduleobj
+        .set("exports", JsValue::from(" "), false, &mut ctx)
+        .unwrap();
+    ctx.register_global_property("module", JsValue::from(moduleobj), Attribute::default());
+
+    // Instantiating the engine with the execution context
+    // Loading, parsing and executing the JS code from the source file
+    ctx.eval(&buffer.unwrap()).unwrap();
+}
+
+// Custom implementation that mimics the 'require' module loader
+fn require(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JsValue> {
+    let arg = args.get(0).unwrap();
+
+    // BUG: Dev branch seems to be passing string arguments along with quotes
+    let libfile = arg
+        .to_string(ctx)
+        .expect("Failed to convert to string")
+        .to_string();
+
+    // Read the module source file
+    println!("Loading: {}", libfile);
+    let buffer = read_to_string(libfile);
+    if let Err(..) = buffer {
+        println!("Error: {}", buffer.unwrap_err());
+        Ok(JsValue::Rational(-1.0))
+    } else {
+        // Load and parse the module source
+        ctx.eval(&buffer.unwrap()).unwrap();
+
+        // Access module.exports and return as ResultValue
+        let global_obj = ctx.global_object().to_owned();
+        let module = global_obj.get("module", ctx).unwrap();
+        module.as_object().unwrap().get("exports", ctx)
+    }
+}