CFEngine extensions (#1)

Author: m4rtinh4rt

Cargo.toml

@@ -9,10 +9,12 @@ license = "MIT/Apache-2.0"
 
 [features]
 unstable = []
+CFEngine = []
 
 [dependencies]
 log = "0.3.5"
 serde = "1.0.0"
+serde_json = "1.0.0"
 
 [dev-dependencies]
 serde_derive = "1.0.0"

src/data.rs

@@ -1,6 +1,7 @@
-use std::cell::RefCell;
+use serde::ser::{SerializeMap, SerializeSeq};
 use std::collections::HashMap;
 use std::fmt;
+use std::{cell::RefCell, collections::BTreeMap};
 
 // for bug!
 use log::{error, log};
@@ -14,6 +15,35 @@ pub enum Data {
     Fun(RefCell<Box<dyn FnMut(String) -> String + Send>>),
 }
 
+impl serde::Serialize for Data {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match *self {
+            Data::Null => serializer.serialize_none(),
+            Data::String(ref v) => serializer.serialize_str(v),
+            Data::Bool(v) => serializer.serialize_bool(v),
+            Data::Vec(ref v) => {
+                let mut seq = serializer.serialize_seq(Some(v.len()))?;
+                for e in v {
+                    seq.serialize_element(e)?;
+                }
+                seq.end()
+            }
+            Data::Map(ref v) => {
+                let v: BTreeMap<_, _> = v.into_iter().collect();
+                let mut map = serializer.serialize_map(Some(v.len()))?;
+                for (k, va) in v {
+                    map.serialize_entry(k, va)?;
+                }
+                map.end()
+            }
+            Data::Fun(_) => serializer.serialize_unit(),
+        }
+    }
+}
+
 impl PartialEq for Data {
     #[inline]
     fn eq(&self, other: &Data) -> bool {

src/lib.rs

@@ -3,6 +3,7 @@
 
 extern crate log;
 extern crate serde;
+extern crate serde_json;
 
 use std::path::{Path, PathBuf};
 use std::result;

src/parser.rs

@@ -23,6 +23,18 @@ pub enum Token {
     ),
     IncompleteSection(Vec<String>, bool, String, bool),
     Partial(String, String, String),
+    #[cfg(feature = "CFEngine")]
+    At,
+    #[cfg(feature = "CFEngine")]
+    JSON(Vec<String>, String),
+    #[cfg(feature = "CFEngine")]
+    JSONMulti(Vec<String>, String),
+    #[cfg(feature = "CFEngine")]
+    TopJSON(Vec<String>, String),
+    #[cfg(feature = "CFEngine")]
+    TopJSONMulti(Vec<String>, String),
+    #[cfg(feature = "CFEngine")]
+    TopSection(Vec<Token>),
 }
 
 /// Error type to represent parsing failure.
@@ -374,15 +386,38 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                 // ignore comments
                 self.eat_whitespace();
             }
-            '&' => {
+            #[cfg(feature = "CFEngine")]
+            '%' => {
+                // Data to be rendered as multi-line JSON representation
                 let name = &content[1..len];
                 let name = get_name_or_implicit(name)?;
+
+                self.tokens
+                    .push(if name.first() == Some(&"-top-".to_string()) {
+                        Token::TopJSONMulti(name, tag)
+                    } else {
+                        Token::JSONMulti(name, tag)
+                    });
+            }
+            #[cfg(feature = "CFEngine")]
+            '$' => {
+                // Data to be rendered as compact JSON representation
+                let name = get_name_or_implicit(&content[1..len])?;
+
+                self.tokens
+                    .push(if name.first() == Some(&"-top-".to_string()) {
+                        Token::TopJSON(name, tag)
+                    } else {
+                        Token::JSON(name, tag)
+                    });
+            }
+            '&' => {
+                let name = get_name_or_implicit(&content[1..len])?;
                 self.tokens.push(Token::UnescapedTag(name, tag));
             }
             '{' => {
                 if content.ends_with('}') {
-                    let name = &content[1..len - 1];
-                    let name = get_name_or_implicit(name)?;
+                    let name = get_name_or_implicit(&content[1..len - 1])?;
                     self.tokens.push(Token::UnescapedTag(name, tag));
                 } else {
                     return Err(Error::UnbalancedUnescapeTag);
@@ -402,6 +437,10 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                 self.tokens
                     .push(Token::IncompleteSection(name, true, tag, newlined));
             }
+            #[cfg(feature = "CFEngine")]
+            '@' => {
+                self.tokens.push(Token::At);
+            }
             '/' => {
                 self.eat_whitespace();
 
@@ -423,6 +462,12 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                             let mut srcs = Vec::new();
                             for child in children.iter() {
                                 match *child {
+                                    #[cfg(feature = "CFEngine")]
+                                    Token::JSON(_, ref s)
+                                    | Token::JSONMulti(_, ref s)
+                                    | Token::TopJSON(_, ref s)
+                                    | Token::TopJSONMulti(_, ref s) => srcs.push(s.clone()),
+
                                     Token::Text(ref s)
                                     | Token::EscapedTag(_, ref s)
                                     | Token::UnescapedTag(_, ref s)
@@ -455,6 +500,24 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                                     src.push_str(s);
                                 }
 
+                                #[cfg(feature = "CFEngine")]
+                                self.tokens
+                                    .push(if name.first() == Some(&"-top-".to_string()) {
+                                        Token::TopSection(children)
+                                    } else {
+                                        Token::Section(
+                                            name,
+                                            inverted,
+                                            children,
+                                            self.opening_tag.clone(),
+                                            osection,
+                                            src,
+                                            tag,
+                                            self.closing_tag.clone(),
+                                        )
+                                    });
+
+                                #[cfg(not(feature = "CFEngine"))]
                                 self.tokens.push(Token::Section(
                                     name,
                                     inverted,
@@ -465,6 +528,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                                     tag,
                                     self.closing_tag.clone(),
                                 ));
+
                                 break;
                             } else {
                                 return Err(Error::UnclosedSection(section_name.join(".")));
@@ -763,4 +827,39 @@ mod tests {
         let input = "{{=<% %>=}} <%{ %>";
         assert_eq!(parse(input), Err(Error::UnbalancedUnescapeTag))
     }
+
+    mod cfengine {
+        use super::*;
+
+        #[test]
+        fn test_json_multi() {
+            assert!(parse("{{%var}}").is_ok());
+        }
+
+        #[test]
+        fn test_json_compact() {
+            assert!(parse("{{$var}}").is_ok());
+        }
+
+        #[test]
+        fn test_top() {
+            assert!(parse("{{%-top-}}").is_ok());
+            assert!(parse("{{$-top-}}").is_ok());
+        }
+
+        #[test]
+        fn test_top_section() {
+            assert!(parse("{{#-top-}} {{.}}{{/-top-}}").is_ok());
+        }
+
+        #[test]
+        fn test_at() {
+            assert!(parse("{{#-top-}} {{{@}}}{{/-top-}}").is_ok());
+        }
+
+        #[test]
+        fn test_at_dot() {
+            assert!(parse("{{#-top-}} {{{@}}} {{.}}{{/-top-}}").is_ok());
+        }
+    }
 }