Replace ALL of the nu stuff with embed-nu
parent
8d37f60cd7
commit
fd97b535df
GPG Key ID:
DFFFCC2C7A02DB45
@ -1,232 +0,0 @@
|
|||||||
#![allow(unused)]
|
|
||||||
use std::{
|
|
||||||
collections::HashMap,
|
|
||||||
mem,
|
|
||||||
path::{Path, PathBuf},
|
|
||||||
};
|
|
||||||
|
|
||||||
use nu_cli::gather_parent_env_vars;
|
|
||||||
use tokio::fs;
|
|
||||||
|
|
||||||
use miette::IntoDiagnostic;
|
|
||||||
use nu_protocol::{
|
|
||||||
ast::{Argument, Block, Call, Expr, Expression, Pipeline},
|
|
||||||
engine::{EngineState, Stack, StateDelta, StateWorkingSet},
|
|
||||||
DeclId, PipelineData, Signature, Span, Type, Value,
|
|
||||||
};
|
|
||||||
|
|
||||||
use crate::error::{AppError, AppResult};
|
|
||||||
|
|
||||||
use super::record::RecordValue;
|
|
||||||
|
|
||||||
/// An executor for nu scripts
|
|
||||||
pub struct NuExecutor {
|
|
||||||
script_path: PathBuf,
|
|
||||||
args: Vec<RecordValue>,
|
|
||||||
global_vars: HashMap<String, RecordValue>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl NuExecutor {
|
|
||||||
pub fn new<P: AsRef<Path>>(script_path: P) -> Self {
|
|
||||||
Self {
|
|
||||||
script_path: script_path.as_ref().to_owned(),
|
|
||||||
args: Vec::new(),
|
|
||||||
global_vars: HashMap::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn add_arg<A: Into<RecordValue>>(&mut self, arg: A) -> &mut Self {
|
|
||||||
self.args.push(arg.into());
|
|
||||||
|
|
||||||
self
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn add_args<A: Into<RecordValue>, I: IntoIterator<Item = A>>(
|
|
||||||
&mut self,
|
|
||||||
args: I,
|
|
||||||
) -> &mut Self {
|
|
||||||
let mut args = args.into_iter().map(|a| a.into()).collect::<Vec<_>>();
|
|
||||||
self.args.append(&mut args);
|
|
||||||
|
|
||||||
self
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds a global variable to the executor which can
|
|
||||||
/// be accessed from within the script
|
|
||||||
pub fn add_global_var<S: ToString, V: Into<RecordValue>>(
|
|
||||||
&mut self,
|
|
||||||
name: S,
|
|
||||||
value: V,
|
|
||||||
) -> &mut Self {
|
|
||||||
self.global_vars.insert(name.to_string(), value.into());
|
|
||||||
|
|
||||||
self
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds multiple global variables
|
|
||||||
pub fn add_global_vars<S: ToString, R: Into<RecordValue>, I: IntoIterator<Item = (S, R)>>(
|
|
||||||
&mut self,
|
|
||||||
vars: I,
|
|
||||||
) -> &mut Self {
|
|
||||||
self.global_vars
|
|
||||||
.extend(&mut vars.into_iter().map(|(k, v)| (k.to_string(), v.into())));
|
|
||||||
|
|
||||||
self
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Executes the given script file in a clean nu context.
|
|
||||||
#[tracing::instrument(level = "trace", skip_all)]
|
|
||||||
pub async fn execute(&mut self) -> AppResult<()> {
|
|
||||||
let mut engine_state = nu_command::create_default_context();
|
|
||||||
let mut stack = nu_protocol::engine::Stack::new();
|
|
||||||
let init_cwd = nu_cli::get_init_cwd();
|
|
||||||
gather_parent_env_vars(&mut engine_state, &init_cwd);
|
|
||||||
nu_engine::convert_env_values(&mut engine_state, &stack);
|
|
||||||
|
|
||||||
let vars = mem::take(&mut self.global_vars);
|
|
||||||
let vars = vars
|
|
||||||
.into_iter()
|
|
||||||
.map(|(k, v)| (k, v.into_protocol_value()))
|
|
||||||
.collect::<HashMap<_, _>>();
|
|
||||||
|
|
||||||
add_variables_to_state(vars, &mut engine_state, &mut stack);
|
|
||||||
let (block, main_id) = read_script_file(&self.script_path, &mut engine_state).await?;
|
|
||||||
|
|
||||||
// put everything the script defines into scope
|
|
||||||
nu_engine::eval_block(
|
|
||||||
&engine_state,
|
|
||||||
&mut stack,
|
|
||||||
&block,
|
|
||||||
empty_pipeline(),
|
|
||||||
false,
|
|
||||||
false,
|
|
||||||
)
|
|
||||||
.into_diagnostic()?;
|
|
||||||
|
|
||||||
let args = mem::take(&mut self.args);
|
|
||||||
|
|
||||||
// block in a different thread to be able to execute scripts in parallel
|
|
||||||
tokio::task::spawn_blocking(move || {
|
|
||||||
// create a call to the main method wit the given arguments and execute it
|
|
||||||
let call_block = create_call(main_id, args);
|
|
||||||
|
|
||||||
let data = nu_engine::eval_block(
|
|
||||||
&engine_state,
|
|
||||||
&mut stack,
|
|
||||||
&call_block,
|
|
||||||
empty_pipeline(),
|
|
||||||
false,
|
|
||||||
false,
|
|
||||||
)?;
|
|
||||||
// the last print is returned as the result pipeline of the script so
|
|
||||||
// we need to print it manually
|
|
||||||
data.print(&mut engine_state, &mut stack, false, true);
|
|
||||||
|
|
||||||
AppResult::Ok(())
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap()?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds variables to the nu engine state
|
|
||||||
/// Note: Calling this function multiple times will override other variables
|
|
||||||
#[tracing::instrument(level = "trace", skip(state, stack))]
|
|
||||||
fn add_variables_to_state(
|
|
||||||
vars: HashMap<String, Value>,
|
|
||||||
state: &mut EngineState,
|
|
||||||
stack: &mut Stack,
|
|
||||||
) {
|
|
||||||
let state2 = nu_command::create_default_context();
|
|
||||||
let mut working_set = StateWorkingSet::new(&state2);
|
|
||||||
vars.into_iter()
|
|
||||||
.map(|(name, value)| {
|
|
||||||
(
|
|
||||||
working_set.add_variable(
|
|
||||||
name.as_bytes().to_vec(),
|
|
||||||
Span::new(0, 0),
|
|
||||||
nu_protocol::Type::String,
|
|
||||||
),
|
|
||||||
value,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.for_each(|(var_id, value)| stack.add_var(var_id, value));
|
|
||||||
state.merge_delta(working_set.render());
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Reads the nu script file and
|
|
||||||
/// returns its root block
|
|
||||||
#[tracing::instrument(level = "trace", skip(engine_state))]
|
|
||||||
async fn read_script_file(
|
|
||||||
path: &Path,
|
|
||||||
engine_state: &mut EngineState,
|
|
||||||
) -> AppResult<(Block, DeclId)> {
|
|
||||||
let script_contents = fs::read(&path).await.into_diagnostic()?;
|
|
||||||
let string_path = path.to_string_lossy().into_owned();
|
|
||||||
// parse the source file
|
|
||||||
let (block, working_set) = parse_nu(engine_state, &script_contents, Some(&string_path))?;
|
|
||||||
// check if a main method exists in the block
|
|
||||||
if let Some(decl_id) = working_set.find_decl(b"main", &Type::Block) {
|
|
||||||
let delta = working_set.render();
|
|
||||||
engine_state.merge_delta(delta);
|
|
||||||
|
|
||||||
Ok((block, decl_id))
|
|
||||||
} else {
|
|
||||||
Err(AppError::MissingMain(PathBuf::from(path)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Parses a nu script
|
|
||||||
#[tracing::instrument(level = "trace", skip_all)]
|
|
||||||
fn parse_nu<'a>(
|
|
||||||
engine_state: &'a mut EngineState,
|
|
||||||
script: &[u8],
|
|
||||||
script_path: Option<&str>,
|
|
||||||
) -> AppResult<(Block, StateWorkingSet<'a>)> {
|
|
||||||
let mut working_set = StateWorkingSet::new(engine_state);
|
|
||||||
let (block, err) = nu_parser::parse(&mut working_set, script_path, script, false, &[]);
|
|
||||||
|
|
||||||
if let Some(err) = err {
|
|
||||||
Err(AppError::from(err))
|
|
||||||
} else {
|
|
||||||
Ok((block, working_set))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a call nu expression with the given main block declaration ID
|
|
||||||
/// and arguments in the form of record values
|
|
||||||
#[tracing::instrument(level = "trace")]
|
|
||||||
fn create_call(decl_id: DeclId, args: Vec<RecordValue>) -> Block {
|
|
||||||
let args = args
|
|
||||||
.into_iter()
|
|
||||||
.map(|a| Argument::Positional(a.into_expression()))
|
|
||||||
.collect();
|
|
||||||
let call = Call {
|
|
||||||
decl_id,
|
|
||||||
head: Span::new(0, 0),
|
|
||||||
arguments: args,
|
|
||||||
redirect_stdout: true,
|
|
||||||
redirect_stderr: false,
|
|
||||||
};
|
|
||||||
let pipeline = Pipeline {
|
|
||||||
expressions: vec![Expression {
|
|
||||||
expr: Expr::Call(Box::new(call)),
|
|
||||||
span: Span::new(0, 0),
|
|
||||||
ty: Type::Any,
|
|
||||||
custom_completion: None,
|
|
||||||
}],
|
|
||||||
};
|
|
||||||
Block {
|
|
||||||
signature: Box::new(Signature::build("Call to main")),
|
|
||||||
pipelines: vec![pipeline],
|
|
||||||
captures: Vec::new(),
|
|
||||||
redirect_env: false,
|
|
||||||
span: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn empty_pipeline() -> PipelineData {
|
|
||||||
PipelineData::new(Span::new(0, 0))
|
|
||||||
}
|
|
||||||
@ -1,5 +1,2 @@
|
|||||||
pub mod executor;
|
|
||||||
pub mod loader;
|
pub mod loader;
|
||||||
pub mod record;
|
|
||||||
pub mod record_serializer;
|
|
||||||
pub mod script;
|
pub mod script;
|
||||||
|
|||||||
@ -1,190 +0,0 @@
|
|||||||
use std::{borrow::Cow, collections::HashMap};
|
|
||||||
|
|
||||||
use nu_protocol::{
|
|
||||||
ast::{Expr, Expression},
|
|
||||||
Span, Type, Value,
|
|
||||||
};
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub enum RecordValue {
|
|
||||||
Int(i64),
|
|
||||||
Float(f64),
|
|
||||||
String(String),
|
|
||||||
Bytes(Vec<u8>),
|
|
||||||
Boolean(bool),
|
|
||||||
Null,
|
|
||||||
Map(Vec<(RecordValue, RecordValue)>),
|
|
||||||
List(Vec<RecordValue>),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RecordValue {
|
|
||||||
/// Creates an expresion for this value
|
|
||||||
pub fn into_expr(self) -> Expr {
|
|
||||||
match self {
|
|
||||||
RecordValue::Int(i) => Expr::Int(i),
|
|
||||||
RecordValue::Float(f) => Expr::Float(f),
|
|
||||||
RecordValue::String(s) => Expr::String(s),
|
|
||||||
RecordValue::Boolean(b) => Expr::Bool(b),
|
|
||||||
RecordValue::Null => Expr::Nothing,
|
|
||||||
RecordValue::Map(m) => Expr::Record(
|
|
||||||
m.into_iter()
|
|
||||||
.map(|(k, v)| (k.into_expression(), v.into_expression()))
|
|
||||||
.collect(),
|
|
||||||
),
|
|
||||||
RecordValue::List(l) => {
|
|
||||||
Expr::List(l.into_iter().map(RecordValue::into_expression).collect())
|
|
||||||
}
|
|
||||||
RecordValue::Bytes(b) => Expr::Binary(b),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new wrapped expression for this value
|
|
||||||
pub fn into_expression(self) -> Expression {
|
|
||||||
let nu_type = self.get_type();
|
|
||||||
let expr = self.into_expr();
|
|
||||||
|
|
||||||
Expression {
|
|
||||||
expr,
|
|
||||||
span: Span::new(0, 0),
|
|
||||||
ty: nu_type,
|
|
||||||
custom_completion: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a nu protocol value from this value
|
|
||||||
pub fn into_protocol_value(self) -> Value {
|
|
||||||
let span = Span::new(0, 0);
|
|
||||||
|
|
||||||
match self {
|
|
||||||
RecordValue::Int(val) => Value::Int { val, span },
|
|
||||||
RecordValue::Float(val) => Value::Float { val, span },
|
|
||||||
RecordValue::String(val) => Value::String { val, span },
|
|
||||||
RecordValue::Bytes(val) => Value::Binary { val, span },
|
|
||||||
RecordValue::Boolean(val) => Value::Bool { val, span },
|
|
||||||
RecordValue::Null => Value::Nothing { span },
|
|
||||||
RecordValue::Map(m) => {
|
|
||||||
let mut cols = Vec::new();
|
|
||||||
let mut vals = Vec::new();
|
|
||||||
for (key, val) in m {
|
|
||||||
cols.push(key.to_string());
|
|
||||||
vals.push(val.into_protocol_value());
|
|
||||||
}
|
|
||||||
Value::Record { cols, vals, span }
|
|
||||||
}
|
|
||||||
RecordValue::List(l) => Value::List {
|
|
||||||
vals: l
|
|
||||||
.into_iter()
|
|
||||||
.map(RecordValue::into_protocol_value)
|
|
||||||
.collect(),
|
|
||||||
span,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the type of this value
|
|
||||||
fn get_type(&self) -> Type {
|
|
||||||
match &self {
|
|
||||||
RecordValue::Int(_) => Type::Int,
|
|
||||||
RecordValue::Float(_) => Type::Float,
|
|
||||||
RecordValue::String(_) => Type::String,
|
|
||||||
RecordValue::Boolean(_) => Type::Bool,
|
|
||||||
RecordValue::Null => Type::Nothing,
|
|
||||||
RecordValue::Map(m) => {
|
|
||||||
let type_map = m
|
|
||||||
.iter()
|
|
||||||
.map(|(k, v)| (k.to_string(), v.get_type()))
|
|
||||||
.collect();
|
|
||||||
Type::Record(type_map)
|
|
||||||
}
|
|
||||||
RecordValue::List(l) => {
|
|
||||||
let list_type = if let Some(first) = l.first() {
|
|
||||||
first.get_type()
|
|
||||||
} else {
|
|
||||||
Type::Nothing
|
|
||||||
};
|
|
||||||
Type::List(Box::new(list_type))
|
|
||||||
}
|
|
||||||
RecordValue::Bytes(_) => Type::Binary,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ToString for RecordValue {
|
|
||||||
fn to_string(&self) -> String {
|
|
||||||
match self {
|
|
||||||
RecordValue::Int(i) => i.to_string(),
|
|
||||||
RecordValue::Float(f) => f.to_string(),
|
|
||||||
RecordValue::String(s) => s.clone(),
|
|
||||||
RecordValue::Boolean(b) => b.to_string(),
|
|
||||||
RecordValue::Null => String::new(),
|
|
||||||
RecordValue::Map(_) => String::new(),
|
|
||||||
RecordValue::List(_) => String::new(),
|
|
||||||
RecordValue::Bytes(_) => String::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<i64> for RecordValue {
|
|
||||||
fn from(num: i64) -> Self {
|
|
||||||
Self::Int(num)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<f64> for RecordValue {
|
|
||||||
fn from(num: f64) -> Self {
|
|
||||||
Self::Float(num)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<String> for RecordValue {
|
|
||||||
fn from(s: String) -> Self {
|
|
||||||
Self::String(s)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> From<Cow<'a, str>> for RecordValue {
|
|
||||||
fn from(s: Cow<'a, str>) -> Self {
|
|
||||||
Self::String(s.into_owned())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&str> for RecordValue {
|
|
||||||
fn from(s: &str) -> Self {
|
|
||||||
Self::String(s.into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<bool> for RecordValue {
|
|
||||||
fn from(b: bool) -> Self {
|
|
||||||
Self::Boolean(b)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Into<RecordValue>> From<Option<T>> for RecordValue {
|
|
||||||
fn from(opt: Option<T>) -> Self {
|
|
||||||
match opt {
|
|
||||||
Some(val) => val.into(),
|
|
||||||
None => Self::Null,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T1: Into<RecordValue>, T2: Into<RecordValue>> From<HashMap<T1, T2>> for RecordValue {
|
|
||||||
fn from(map: HashMap<T1, T2>) -> Self {
|
|
||||||
let map = map.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
|
|
||||||
Self::Map(map)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Into<RecordValue>> From<Vec<T>> for RecordValue {
|
|
||||||
fn from(list: Vec<T>) -> Self {
|
|
||||||
let list = list.into_iter().map(|l| l.into()).collect();
|
|
||||||
Self::List(list)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<Vec<u8>> for RecordValue {
|
|
||||||
fn from(b: Vec<u8>) -> Self {
|
|
||||||
Self::Bytes(b)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,444 +0,0 @@
|
|||||||
use std::{collections::HashMap, mem};
|
|
||||||
|
|
||||||
use thiserror::Error;
|
|
||||||
|
|
||||||
use super::record::RecordValue;
|
|
||||||
|
|
||||||
#[derive(Default)]
|
|
||||||
pub struct RecordSerializer {
|
|
||||||
list_serializer: Option<RecordListSerializer>,
|
|
||||||
map_serializer: Option<RecordMapSerializer>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Default)]
|
|
||||||
pub struct RecordListSerializer {
|
|
||||||
serializer: Option<Box<RecordSerializer>>,
|
|
||||||
entries: Vec<RecordValue>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Default)]
|
|
||||||
pub struct RecordMapSerializer {
|
|
||||||
serializer: Option<Box<RecordSerializer>>,
|
|
||||||
last_key: Option<RecordValue>,
|
|
||||||
entries: Vec<(RecordValue, RecordValue)>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RecordSerializer {
|
|
||||||
pub fn list_serializer(&mut self, cap: Option<usize>) -> &mut RecordListSerializer {
|
|
||||||
if self.list_serializer.is_none() {
|
|
||||||
self.list_serializer = Some(RecordListSerializer::with_capacity_opt(cap));
|
|
||||||
}
|
|
||||||
self.list_serializer.as_mut().unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn map_serializer(&mut self, cap: Option<usize>) -> &mut RecordMapSerializer {
|
|
||||||
if self.map_serializer.is_none() {
|
|
||||||
self.map_serializer = Some(RecordMapSerializer::with_capacity_opt(cap));
|
|
||||||
}
|
|
||||||
self.map_serializer.as_mut().unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RecordListSerializer {
|
|
||||||
pub fn with_capacity(capacity: usize) -> Self {
|
|
||||||
Self {
|
|
||||||
entries: Vec::with_capacity(capacity),
|
|
||||||
serializer: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_capacity_opt(capacity: Option<usize>) -> Self {
|
|
||||||
match capacity {
|
|
||||||
Some(cap) => Self::with_capacity(cap),
|
|
||||||
None => Self::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn serializer(&mut self) -> &mut RecordSerializer {
|
|
||||||
if self.serializer.is_none() {
|
|
||||||
self.serializer = Some(Box::new(RecordSerializer::default()));
|
|
||||||
}
|
|
||||||
self.serializer.as_mut().unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RecordMapSerializer {
|
|
||||||
pub fn with_capacity(capacity: usize) -> Self {
|
|
||||||
Self {
|
|
||||||
last_key: None,
|
|
||||||
entries: Vec::with_capacity(capacity),
|
|
||||||
serializer: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_capacity_opt(capacity: Option<usize>) -> Self {
|
|
||||||
match capacity {
|
|
||||||
Some(cap) => Self::with_capacity(cap),
|
|
||||||
None => Self::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn serializer(&mut self) -> &mut RecordSerializer {
|
|
||||||
if self.serializer.is_none() {
|
|
||||||
self.serializer = Some(Box::new(RecordSerializer::default()));
|
|
||||||
}
|
|
||||||
self.serializer.as_mut().unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Error, Debug)]
|
|
||||||
pub enum RecordSerError {
|
|
||||||
#[error("{0}")]
|
|
||||||
Msg(String),
|
|
||||||
|
|
||||||
#[error("Encountered map value before map key")]
|
|
||||||
ValueBeforeKey,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl serde::ser::Error for RecordSerError {
|
|
||||||
fn custom<T>(msg: T) -> Self
|
|
||||||
where
|
|
||||||
T: std::fmt::Display,
|
|
||||||
{
|
|
||||||
Self::Msg(msg.to_string())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::Serializer for &'a mut RecordSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
type SerializeSeq = &'a mut RecordListSerializer;
|
|
||||||
|
|
||||||
type SerializeTuple = &'a mut RecordListSerializer;
|
|
||||||
|
|
||||||
type SerializeTupleStruct = &'a mut RecordListSerializer;
|
|
||||||
|
|
||||||
type SerializeTupleVariant = &'a mut RecordListSerializer;
|
|
||||||
|
|
||||||
type SerializeMap = &'a mut RecordMapSerializer;
|
|
||||||
|
|
||||||
type SerializeStruct = &'a mut RecordMapSerializer;
|
|
||||||
|
|
||||||
type SerializeStructVariant = &'a mut RecordMapSerializer;
|
|
||||||
|
|
||||||
fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as i64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok((v as f64).into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.to_string().into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(v.to_vec().into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(RecordValue::Null)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
value.serialize(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
self.serialize_none()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
|
|
||||||
self.serialize_unit()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_unit_variant(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
_variant_index: u32,
|
|
||||||
variant: &'static str,
|
|
||||||
) -> Result<Self::Ok, Self::Error> {
|
|
||||||
self.serialize_str(variant)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_newtype_struct<T: ?Sized>(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
value: &T,
|
|
||||||
) -> Result<Self::Ok, Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
value.serialize(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_newtype_variant<T: ?Sized>(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
_variant_index: u32,
|
|
||||||
variant: &'static str,
|
|
||||||
value: &T,
|
|
||||||
) -> Result<Self::Ok, Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let mut map = HashMap::new();
|
|
||||||
map.insert(variant.to_string(), value.serialize(self)?);
|
|
||||||
Ok(map.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
|
|
||||||
Ok(self.list_serializer(len))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
|
|
||||||
Ok(self.list_serializer(Some(len)))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_tuple_struct(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
len: usize,
|
|
||||||
) -> Result<Self::SerializeTupleStruct, Self::Error> {
|
|
||||||
Ok(self.list_serializer(Some(len)))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_tuple_variant(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
_variant_index: u32,
|
|
||||||
_variant: &'static str,
|
|
||||||
len: usize,
|
|
||||||
) -> Result<Self::SerializeTupleVariant, Self::Error> {
|
|
||||||
Ok(self.list_serializer(Some(len)))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
|
|
||||||
Ok(self.map_serializer(len))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_struct(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
len: usize,
|
|
||||||
) -> Result<Self::SerializeStruct, Self::Error> {
|
|
||||||
Ok(self.map_serializer(Some(len)))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_struct_variant(
|
|
||||||
self,
|
|
||||||
_name: &'static str,
|
|
||||||
_variant_index: u32,
|
|
||||||
_variant: &'static str,
|
|
||||||
len: usize,
|
|
||||||
) -> Result<Self::SerializeStructVariant, Self::Error> {
|
|
||||||
Ok(self.map_serializer(Some(len)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeTuple for &'a mut RecordListSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push(val);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(mem::take(&mut self.entries).into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeSeq for &'a mut RecordListSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push(val);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(mem::take(&mut self.entries).into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeTupleStruct for &'a mut RecordListSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push(val);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(mem::take(&mut self.entries).into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeTupleVariant for &'a mut RecordListSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push(val);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(mem::take(&mut self.entries).into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeMap for &'a mut RecordMapSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = key.serialize(self.serializer())?;
|
|
||||||
self.last_key = Some(val);
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
if let Some(last_key) = self.last_key.take() {
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push((last_key, val));
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
} else {
|
|
||||||
Err(RecordSerError::ValueBeforeKey)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(RecordValue::Map(mem::take(&mut self.entries)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeStruct for &'a mut RecordMapSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(
|
|
||||||
&mut self,
|
|
||||||
key: &'static str,
|
|
||||||
value: &T,
|
|
||||||
) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push((key.into(), val));
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(RecordValue::Map(mem::take(&mut self.entries)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> serde::ser::SerializeStructVariant for &'a mut RecordMapSerializer {
|
|
||||||
type Ok = RecordValue;
|
|
||||||
|
|
||||||
type Error = RecordSerError;
|
|
||||||
|
|
||||||
fn serialize_field<T: ?Sized>(
|
|
||||||
&mut self,
|
|
||||||
key: &'static str,
|
|
||||||
value: &T,
|
|
||||||
) -> Result<(), Self::Error>
|
|
||||||
where
|
|
||||||
T: serde::Serialize,
|
|
||||||
{
|
|
||||||
let val = value.serialize(self.serializer())?;
|
|
||||||
self.entries.push((key.into(), val));
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn end(self) -> Result<Self::Ok, Self::Error> {
|
|
||||||
Ok(RecordValue::Map(mem::take(&mut self.entries)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue