Struct rustyscript::Runtime

source ·
pub struct Runtime(/* private fields */);
Expand description

Represents a configured runtime ready to run modules

Implementations§

source§

impl Runtime

source

pub const EMPTY_ARGS: &'static FunctionArguments = _

The lack of any arguments - used to simplify calling functions Prevents you from needing to specify the type using ::<serde_json::Value>

source

pub fn new(options: RuntimeOptions) -> Result<Self, Error>

Creates a new instance of the runtime with the provided options.

§Arguments
  • options - A RuntimeOptions struct that specifies the configuration options for the runtime.
§Returns

A Result containing either the initialized runtime instance on success (Ok) or an error on failure (Err).

§Example
use rustyscript::{ json_args, Runtime, RuntimeOptions, Module };
use std::time::Duration;

// Creates a runtime that will attempt to run function load() on start
// And which will time-out after 50ms
let mut runtime = Runtime::new(RuntimeOptions {
    default_entrypoint: Some("load".to_string()),
    timeout: Duration::from_millis(50),
    ..Default::default()
})?;

let module = Module::new("test.js", "
    export const load = () => {
        return 'Hello World!';
    }
");

let module_handle = runtime.load_module(&module)?;
let value: String = runtime.call_entrypoint(&module_handle, json_args!())?;
assert_eq!("Hello World!", value);
source

pub fn deno_runtime(&mut self) -> &mut JsRuntime

Access the underlying deno runtime instance directly

source

pub fn options(&self) -> &RuntimeOptions

Access the options used to create this runtime

source

pub fn arg<A>(value: A) -> Result<Value, Error>
where A: Serialize,

Encode an argument as a json value for use as a function argument

use rustyscript::{ Runtime, RuntimeOptions, Module };
use serde::Serialize;
use std::time::Duration;

let module = Module::new("test.js", "
    function load(obj) {
        console.log(`Hello world: a=${obj.a}, b=${obj.b}`);
    }
    rustyscript.register_entrypoint(load);
");

#[derive(Serialize)]
struct MyStruct {a: usize, b: usize}

Runtime::execute_module(
    &module, vec![],
    Default::default(),
    &[
        Runtime::arg(MyStruct{a: 1, b: 2})?,
    ]
)?;
source

pub fn into_arg<A>(value: A) -> Value
where Value: From<A>,

Encode a primitive as a json value for use as a function argument Only for types with Into<Value>. For other types, use Runtime::arg

use rustyscript::{ Runtime, RuntimeOptions, Module };
use std::time::Duration;

let module = Module::new("test.js", "
    function load(a, b) {
        console.log(`Hello world: a=${a}, b=${b}`);
    }
    rustyscript.register_entrypoint(load);
");

Runtime::execute_module(
    &module, vec![],
    Default::default(),
    &[
        Runtime::into_arg("test"),
        Runtime::into_arg(5),
    ]
)?;
source

pub fn take<T>(&mut self) -> Option<T>
where T: 'static,

Remove and return a value from the state, if one exists

use rustyscript::{ Runtime };

let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
source

pub fn put<T>(&mut self, value: T) -> Result<(), Error>
where T: 'static,

Add a value to the state Only one value of each type is stored - additional calls to put overwrite the old value

use rustyscript::{ Runtime };

let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
source

pub fn register_function( &mut self, name: &str, callback: RsFunction ) -> Result<(), Error>

Register a rust function to be callable from JS

use rustyscript::{ Runtime, Module, serde_json::Value };

let module = Module::new("test.js", " rustyscript.functions.foo(); ");
let mut runtime = Runtime::new(Default::default())?;
runtime.register_function("foo", |args, _state| {
    if let Some(value) = args.get(0) {
        println!("called with: {}", value);
    }
    Ok(Value::Null)
})?;
source

pub fn call_stored_function<T>( &mut self, module_context: &ModuleHandle, function: &JsFunction<'_>, args: &FunctionArguments ) -> Result<T, Error>

Calls a stored javascript function and deserializes its return value.

§Arguments
  • function - A The function object
§Returns

A Result containing the deserialized result of the function call (T) or an error (Error) if the function cannot be found, if there are issues with calling the function, or if the result cannot be deserialized.

source

pub fn call_function<T>( &mut self, module_context: &ModuleHandle, name: &str, args: &FunctionArguments ) -> Result<T, Error>

Calls a javascript function within the Deno runtime by its name and deserializes its return value.

§Arguments
  • name - A string representing the name of the javascript function to call.
§Returns

A Result containing the deserialized result of the function call (T) or an error (Error) if the function cannot be found, if there are issues with calling the function, or if the result cannot be deserialized.

§Example
use rustyscript::{ json_args, Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "export function f() { return 2; };");
let module = runtime.load_module(&module)?;
let value: usize = runtime.call_function(&module, "f", json_args!())?;
source

pub fn get_value<T>( &mut self, module_context: &ModuleHandle, name: &str ) -> Result<T, Error>

Get a value from a runtime instance

§Arguments
  • name - A string representing the name of the value to find
§Returns

A Result containing the deserialized result or an error (Error) if the value cannot be found, if there are issues with, or if the result cannot be deserialized.

§Example
use rustyscript::{ Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "globalThis.my_value = 2;");
let module = runtime.load_module(&module)?;
let value: usize = runtime.get_value(&module, "my_value")?;
source

pub fn load_module(&mut self, module: &Module) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values And call functions

§Arguments
  • module - A Module object containing the module’s filename and contents.
§Returns

A Result containing a handle for the loaded module or an error (Error) if there are issues with loading modules, executing the module, or if the result cannot be deserialized.

§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "rustyscript.register_entrypoint(() => 'test')");
runtime.load_module(&module);
source

pub fn load_modules( &mut self, module: &Module, side_modules: Vec<&Module> ) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values And call functions.

This will load ‘module’ as the main module, and the others as side-modules. Only one main module can be loaded per runtime

§Arguments
  • module - A Module object containing the module’s filename and contents.
  • side_modules - A set of additional modules to be loaded into memory for use
§Returns

A Result containing a handle for the loaded module or an error (Error) if there are issues with loading modules, executing the module, or if the result cannot be deserialized.

§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "rustyscript.register_entrypoint(() => 'test')");
runtime.load_modules(&module, vec![]);
source

pub fn call_entrypoint<T>( &mut self, module_context: &ModuleHandle, args: &FunctionArguments ) -> Result<T, Error>

Executes the entrypoint function of a module within the Deno runtime.

§Arguments
  • module_context - A handle returned by loading a module into the runtime
§Returns

A Result containing the deserialized result of the entrypoint execution (T) if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Example
use rustyscript::{json_args, Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "rustyscript.register_entrypoint(() => 'test')");
let module = runtime.load_module(&module)?;

// Run the entrypoint and handle the result
let value: String = runtime.call_entrypoint(&module, json_args!())?;
source

pub fn execute_module<T>( module: &Module, side_modules: Vec<&Module>, runtime_options: RuntimeOptions, entrypoint_args: &FunctionArguments ) -> Result<T, Error>

Loads a module into a new runtime, executes the entry function and returns the result of the module’s execution, deserialized into the specified Rust type (T).

§Arguments
  • module - A Module object containing the module’s filename and contents.
  • side_modules - A set of additional modules to be loaded into memory for use
  • runtime_options - Options for the creation of the runtime
  • entrypoint_args - Arguments to pass to the entrypoint function
§Returns

A Result containing the deserialized result of the entrypoint execution (T) if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Example
// Create a module with filename and contents
use rustyscript::{json_args, Runtime, Module, Error};

let module = Module::new("test.js", "rustyscript.register_entrypoint(() => 2)");
let value: usize = Runtime::execute_module(&module, vec![], Default::default(), json_args!())?;

Auto Trait Implementations§

§

impl Freeze for Runtime

§

impl !RefUnwindSafe for Runtime

§

impl !Send for Runtime

§

impl !Sync for Runtime

§

impl Unpin for Runtime

§

impl !UnwindSafe for Runtime

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Conv for T

source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
source§

impl<T> FmtForward for T

source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pipe for T
where T: ?Sized,

source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> Tap for T

source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
source§

impl<T> TryConv for T

source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> Send for T
where T: ?Sized,

source§

impl<T> Sync for T
where T: ?Sized,