Expand description
§embed-nu
embed-nu can be used to call nu scripts and expressions from within your rust application. This crate provides a wrapper around the nu engine to easily build the nu execution context, parse scripts and call functions. As this crate includes nu as a dependency calls to nu don’t have the overhead of calling an external application.
§Example Usage
use embed_nu::{rusty_value::*, CommandGroupConfig, Context, NewEmpty, PipelineData};
fn main() {
let mut ctx = Context::builder()
.with_command_groups(CommandGroupConfig::default().all_groups(true))
.unwrap()
.add_parent_env_vars()
.build()
.unwrap();
// eval a nu expression
let pipeline = ctx
.eval_raw(
r#"echo "Hello World from this eval""#,
PipelineData::empty(),
)
.unwrap();
// print the pipeline of this expression. In this case
// this pipeline contains the text of the echo expression
// as it's the last expressin
ctx.print_pipeline(pipeline).unwrap();
// this eval put's the function definition of hello into scope
ctx.eval_raw(
r#"
def hello [] {
echo "Hello World from this script";
echo # dummy echo so I don't have to print the output
}
"#,
PipelineData::empty(),
)
.unwrap();
// hello can now be called as a function
ctx.call_fn("hello", [] as [String; 0]).unwrap();
}
§Converting data into nu values
This crate uses rusty-value to convert any rust data type into nu values.
use embed_nu::{rusty_value::*, IntoValue};
// derive rusty value
#[derive(RustyValue)]
struct MyStruct {
foo: String,
bar: usize,
}
fn main() {
let instance = MyStruct {
foo: String::from("foo"),
bar: 12
};
// convert this struct into a nu value
// this is also done implicitly when passing the value to the nu context
// as function arguments or variables
let value = instance.into_value();
dbg!(value);
}
Re-exports§
pub use nu_engine;
pub use nu_parser;
pub use nu_protocol;
pub use rusty_value;
Modules§
Structs§
- Enables or disables certain command groups
- Represents the evaluation context of nu scripts and commands This context is the state of the engine itself plus the stack It stores variables on
- Builder to create a new nu engine state
- A helper struct to allow IntoValue operations for nu values
Enums§
- A struct representing the argument to a function
- The foundational abstraction for input and output to commands
- Core structured values that pass through the pipeline in Nushell.
Traits§
- Converts a given type into an argument
- Converts the given type into a value This trait is implemented for all types that Implement the RustyValue trait
- Helper trait to avoid conflicts