nu_plugin_handlebars 0.1.0

An `handlebars` command for Nushell for rendering Nu values using Handlebars templates
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

mod registry;
mod template;

use std::sync::RwLock;

use hashbrown::HashMap;
pub use registry::RegistryReference;
pub use template::{TemplateObject, TemplateReference};
use uuid::Uuid;

pub trait CustomReference: Clone {
    type Data;
    const NAME: &str;

    fn uuid(&self) -> &Uuid;
}

#[derive(Debug)]
pub struct CustomEntry<C: CustomReference> {
    pub reference: C,
    pub refcount: usize,
    pub data: C::Data,
}

#[derive(Default, Debug)]
pub struct CustomCollections {
    pub registries: RwLock<HashMap<Uuid, CustomEntry<RegistryReference>>>,
    pub templates: RwLock<HashMap<Uuid, CustomEntry<TemplateReference>>>,
}

impl CustomCollections {
    pub fn is_empty(&self) -> bool {
        self.registries.read().unwrap().is_empty() && self.templates.read().unwrap().is_empty()
    }
}

#[macro_export]
macro_rules! declare_reference_type {
    ($ref_type:ident, $obj_type:ty, $obj_name:literal) => {
        #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
        pub struct $ref_type(pub uuid::Uuid);

        impl $ref_type {
            pub(crate) fn into_value(self, span: nu_protocol::Span) -> nu_protocol::Value {
                nu_protocol::Value::custom(Box::new(self), span)
            }
        }

        #[typetag::serde]
        impl nu_protocol::CustomValue for $ref_type {
            fn clone_value(&self, span: nu_protocol::Span) -> nu_protocol::Value {
                self.clone().into_value(span)
            }

            fn type_name(&self) -> String {
                $obj_name.to_owned()
            }

            fn to_base_value(
                &self,
                span: nu_protocol::Span,
            ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
                Ok(nu_protocol::Value::string(
                    format!("<{}:{}>", $obj_name, self.0),
                    span,
                ))
            }

            fn as_any(&self) -> &dyn std::any::Any {
                self
            }

            fn as_mut_any(&mut self) -> &mut dyn std::any::Any {
                self
            }

            fn notify_plugin_on_drop(&self) -> bool {
                true
            }
        }

        impl $crate::custom_value::CustomReference for $ref_type {
            type Data = $obj_type;
            const NAME: &str = $obj_name;

            fn uuid(&self) -> &uuid::Uuid {
                &self.0
            }
        }

        impl nu_protocol::FromValue for $ref_type {
            fn from_value(v: nu_protocol::Value) -> Result<Self, nu_protocol::ShellError> {
                let custom = v.as_custom_value()?;
                custom
                    .as_any()
                    .downcast_ref()
                    .ok_or_else(|| nu_protocol::ShellError::TypeMismatch {
                        err_message: format!("Expected {}, got {}", $obj_name, custom.type_name()),
                        span: v.span(),
                    })
                    .cloned()
            }

            fn expected_type() -> nu_protocol::Type {
                nu_protocol::Type::custom($obj_name)
            }
        }
    };
}