()
28 | }
29 | };
30 | Ok(Some(ex(value)))
31 | },
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/loader/filesystem.rs:
--------------------------------------------------------------------------------
1 | use std::fs::File;
2 | use std::io::Read;
3 | use std::path::PathBuf;
4 |
5 | use ::abc::{Loader, LoadResult, LoadError};
6 |
7 | #[derive(Debug)]
8 | pub struct FilesystemLoader {
9 | path: PathBuf,
10 | }
11 |
12 | impl FilesystemLoader {
13 | pub fn new(path: P) -> Box where P: Into {
14 | Box::new(FilesystemLoader { path: path.into() })
15 | }
16 | }
17 |
18 | impl Loader for FilesystemLoader {
19 | fn load(&self, name: &str) -> LoadResult {
20 | // TODO Real Security
21 | if name.contains("..") {
22 | return Err(LoadError::BadName(r#"".." is not supported in a name"#.into()))
23 | }
24 | let mut path = self.path.join(name);
25 | if path.extension().is_none() {
26 | path.set_extension("tpl");
27 | }
28 | debug!("Load template: {}, path: {:?}", name, path);
29 | if !path.exists() || !path.is_file() {
30 | return Err(LoadError::NotFound);
31 | }
32 | let mut buf = String::new();
33 | File::open(&path)
34 | .and_then(|mut f| f.read_to_string(&mut buf).map(|_| () ))
35 | .map_err(|err| LoadError::IoError(format!("{:?}; {:?}", err, path).into()))?;
36 | Ok(buf.into())
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/filter/url_unescape.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 |
3 | use abc::{Filter, FilterResult, FilterError};
4 | use renderer::Writer;
5 | use {VarContext, ex, Arg};
6 |
7 |
8 | #[derive(Debug)]
9 | pub struct UrlUnescape;
10 |
11 | impl Filter for UrlUnescape {
12 | #[allow(unused_variables)]
13 | fn filter<'s: 'a, 'a>(&'s self, context: &'a VarContext, value: Option>) -> FilterResult> {
14 | use url::percent_encoding::percent_decode;
15 |
16 | match value {
17 | None => Ok(None),
18 | Some(value) => {
19 | match value.try_as_string() {
20 | None => {
21 | let mut tmp = String::new();
22 | value.render(&mut Writer(&mut tmp))?;
23 | percent_decode(tmp.as_bytes())
24 | .decode_utf8()
25 | .map(Cow::into_owned)
26 | },
27 | Some(string) => {
28 | percent_decode(string.as_bytes())
29 | .decode_utf8()
30 | .map(Cow::into_owned)
31 | }
32 | }
33 | .map(ex).map(Some)
34 | .map_err(|err| FilterError::Process(format!("{:?}", err).into()))
35 | },
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2016 Incrust developers
2 | //
3 | // Licensed under the Apache License, Version 2.0
4 | // or the MIT
5 | // license , at your
6 | // option. All files in the project carrying such notice may not be copied,
7 | // modified, or distributed except according to those terms.
8 |
9 | #![feature(associated_type_defaults)]
10 | #![feature(box_syntax)]
11 | #![feature(specialization)]
12 |
13 | #![allow(clippy::items_after_statements)]
14 | #![allow(clippy::match_bool)]
15 |
16 | #![cfg_attr(feature = "quiet", allow(warnings))]
17 |
18 |
19 | extern crate marksman_escape;
20 | #[macro_use]
21 | extern crate log;
22 | #[macro_use]
23 | extern crate maplit;
24 | #[macro_use]
25 | extern crate nom;
26 | extern crate url;
27 |
28 |
29 | pub mod abc;
30 | pub mod container;
31 | pub mod loader;
32 | pub mod filter;
33 | pub mod parser;
34 | pub mod renderer;
35 | pub mod types;
36 |
37 | pub use self::abc::Loader;
38 | pub use self::container::args::{Arg, Args, EntityId, ex};
39 | pub use self::container::stack::{Stack, VarContext};
40 | pub use self::container::incrust::Incrust;
41 | pub use self::container::template::Template;
42 | pub use self::loader::{DictLoader, FilesystemLoader, GroupLoader, NamespaceLoader};
43 | pub use self::types::abc::Type;
44 | pub use self::types::function::Function;
45 |
--------------------------------------------------------------------------------
/src/filter/newline2space.rs:
--------------------------------------------------------------------------------
1 | use abc::{Filter, FilterResult};
2 | use {VarContext, ex, Arg};
3 |
4 |
5 | #[derive(Debug)]
6 | pub struct NewlineToSpace;
7 |
8 | impl Filter for NewlineToSpace {
9 | #[allow(unused_variables)]
10 | fn filter<'s: 'a, 'a>(&'s self, context: &'a VarContext, value: Option>) -> FilterResult> {
11 | match value {
12 | None => Ok(None),
13 | Some(value) => {
14 | let value = match value.try_as_string() {
15 | None => String::new(),
16 | Some(string) => string.replace(is_nl, " "),
17 | };
18 | Ok(Some(ex(value)))
19 | },
20 | }
21 | }
22 | }
23 |
24 | fn is_nl(c: char) -> bool {
25 | match c {
26 | '\n' | '\r' => true,
27 | _ => false,
28 | }
29 | }
30 |
31 |
32 | #[cfg(test)]
33 | mod tests {
34 | #![allow(clippy::used_underscore_binding)]
35 |
36 | use {Incrust, ex, Args};
37 |
38 | #[test]
39 | fn it_works() {
40 | let incrust = Incrust::default();
41 | let test = |expected, sample| {
42 | let args: Args = hashmap!{ "sample".into() => ex(sample) };
43 | assert_eq!(expected, incrust.render_text("{{ sample | newline_to_space }}", &args).unwrap());
44 | };
45 |
46 | test("", "");
47 | test(" ", " ");
48 | test(" ", "\n");
49 | test(" ", "\r");
50 | test(" ", "\r\n");
51 | test(" ", " \n");
52 | test(" ", "\n ");
53 | test(" ", " \n ");
54 | test("1 2", "1\n2");
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | branches:
2 | only:
3 | - master
4 | - staging
5 | - trying
6 |
7 | dist: trusty
8 | sudo: false
9 |
10 | addons:
11 | apt:
12 | packages:
13 | - gcc
14 | - g++
15 | - libssl-dev
16 | - libelf-dev
17 | - libdw-dev
18 | - binutils-dev
19 | - libiberty-dev
20 | - pkg-config
21 |
22 | language: rust
23 | rust:
24 | - nightly-2018-11-18
25 |
26 | matrix:
27 | allow_failures:
28 | - rust: nightly
29 |
30 | cache:
31 | directories:
32 | - "$HOME/.cargo"
33 | - "$HOME/.local"
34 | - "$TRAVIS_BUILD_DIR/target"
35 |
36 | env:
37 | global:
38 | - DEADLINKS_VERS=0.3.0
39 | - RUSTFLAGS="-C link-dead-code"
40 | - RUST_LOG=off
41 |
42 | install:
43 | - cargo install --list
44 | - cd $TRAVIS_BUILD_DIR
45 | - cargo update
46 |
47 | script: skip
48 |
49 | jobs:
50 | include:
51 | - stage: test
52 | env:
53 | - FEATURE=test
54 | rust: nightly-2018-11-18
55 | script:
56 | - cargo test --verbose --all
57 |
58 | - stage: test
59 | env:
60 | - FEATURE=test
61 | rust: nightly
62 | script:
63 | - cargo test --verbose --all
64 |
65 | - stage: quality
66 | env:
67 | - FEATURE=non-fatal-checks
68 | install:
69 | - cargo-deadlinks -V | grep $DEADLINKS_VERS || cargo install cargo-deadlinks --vers $DEADLINKS_VERS --force
70 | script:
71 | - cargo doc --no-deps && cargo deadlinks --dir target/doc || true
72 |
73 | - stage: quality
74 | env:
75 | - FEATURE=clippy
76 | rust: nightly-2018-11-18
77 | install:
78 | - rustup component add clippy-preview
79 | script:
80 | - cargo clippy -- -D warnings
81 |
--------------------------------------------------------------------------------
/src/types/real.rs:
--------------------------------------------------------------------------------
1 | use std::cmp::Ordering;
2 |
3 | use types::abc::*;
4 | use Arg;
5 |
6 |
7 | impl <'t> Type<'t> for f64 {
8 | fn clone_type(&self) -> Arg<'static> {
9 | Arg::Owned(box *self)
10 | }
11 | }
12 |
13 |
14 | impl AsBool for f64 {
15 | fn to_bool(&self) -> bool {
16 | *self != 0.0
17 | }
18 | }
19 |
20 |
21 | impl AsReal for f64 {
22 | fn try_as_real(&self) -> Option {
23 | Some(*self)
24 | }
25 |
26 | fn is_real(&self) -> bool {
27 | true
28 | }
29 | }
30 |
31 |
32 | impl AsInt for f64 {
33 | fn try_as_int(&self) -> Option {
34 | Some(*self as i64)
35 | }
36 | }
37 |
38 |
39 | impl IPartialEq for f64 {
40 | fn eq<'o>(&self, other: &'o Arg<'o>) -> bool {
41 | other.try_as_real().map(|s| s == *self).unwrap_or(false)
42 | }
43 | }
44 |
45 |
46 | impl IPartialOrd for f64 {
47 | fn partial_cmp<'o>(&self, other: &'o Arg<'o>) -> Option {
48 | if other.is_real() || other.is_int() {
49 | other.try_as_real().and_then(|s| (self as &PartialOrd).partial_cmp(&s))
50 | } else {
51 | None
52 | }
53 | }
54 | }
55 |
56 |
57 | impl IArithm for f64 {
58 | // todo Cow::Borrowed for Zero and One cases
59 | fn try_add<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_real().map(|s| { Arg::Owned(box (*self + s)) }) }
60 | fn try_sub<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_real().map(|s| { Arg::Owned(box (*self - s)) }) }
61 | fn try_mul<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_real().map(|s| { Arg::Owned(box (*self * s)) }) }
62 | fn try_div<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_real().map(|s| { Arg::Owned(box (*self / s)) }) }
63 | }
64 |
--------------------------------------------------------------------------------
/src/types/function.rs:
--------------------------------------------------------------------------------
1 | use std::fmt::{Debug, Formatter, Error};
2 |
3 | use abc::EvalResult;
4 | use VarContext;
5 |
6 | use types::abc::*;
7 | use Arg;
8 |
9 |
10 | pub struct Function {
11 | pub f: for <'res, 'ctx> fn(&[Arg<'res>], &'ctx VarContext<'res>) -> EvalResult>,
12 | }
13 |
14 | impl Function {
15 | // TODO update API to satisfy convention
16 | #[allow(clippy::new_ret_no_self)]
17 | pub fn new(f: for <'res, 'ctx> fn(&[Arg<'res>], &'ctx VarContext<'res>) -> EvalResult>) -> Arg<'static> {
18 | Arg::Owned(box Function { f })
19 | }
20 | }
21 |
22 | impl Clone for Function {
23 | fn clone(&self) -> Self {
24 | Function { f: self.f }
25 | }
26 | }
27 |
28 | impl Debug for Function {
29 | fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
30 | fmt.write_str("AnonymousFunction")
31 | }
32 | }
33 |
34 | impl <'t> Type<'t> for Function {
35 | fn clone_type(&self) -> Arg<'static> {
36 | Arg::Owned(box self.clone())
37 | }
38 | }
39 |
40 | impl IInvokable for Function {
41 | fn invoke<'r: 'a + 'c, 'a, 'c>(&self, args: &'a [Arg<'r>], context: &'c VarContext<'r>) -> EvalResult> {
42 | (self.f)(args, context)
43 | }
44 | }
45 |
46 |
47 |
48 | // --------------------------------------------------------------------------------------------------------------------
49 |
50 |
51 | //impl Type for (fn(&[BType], &Context) -> EvalResult) {
52 | // fn iclone<'a>(&self) -> BType<'a> { Box::new(self.clone()) }
53 | // fn to_bool(&self) -> bool { true }
54 | //}
55 | //
56 | //impl <'a, 'b: 'a> IInvokable<'a> for (fn(&[BType], &Context) -> EvalResult) {
57 | // fn invoke(&self, args: &[BType], context: &Context) -> EvalResult {
58 | // self(args, context, env)
59 | // }
60 | //}
61 |
62 |
63 |
--------------------------------------------------------------------------------
/src/types/int.rs:
--------------------------------------------------------------------------------
1 | use std::cmp::Ordering;
2 |
3 | use types::abc::*;
4 | use Arg;
5 |
6 |
7 | impl <'t> Type<'t> for i64 {
8 | fn clone_type(&self) -> Arg<'static> {
9 | Arg::Owned(box *self)
10 | }
11 | }
12 |
13 | impl AsBool for i64 {
14 | fn to_bool(&self) -> bool {
15 | *self != 0
16 | }
17 | }
18 |
19 | impl AsReal for i64 {
20 | fn try_as_real(&self) -> Option {
21 | Some(*self as f64)
22 | }
23 | }
24 |
25 | impl AsInt for i64 {
26 | fn try_as_int(&self) -> Option {
27 | Some(*self)
28 | }
29 |
30 | fn is_int(&self) -> bool {
31 | true
32 | }
33 | }
34 |
35 |
36 | impl IPartialEq for i64 {
37 | fn eq<'o>(&self, other: &'o Arg<'o>) -> bool {
38 | other.try_as_int().map(|s| s == *self).unwrap_or(false)
39 | }
40 | }
41 |
42 |
43 | impl IPartialOrd for i64 {
44 | fn partial_cmp<'o>(&self, other: &'o Arg<'o>) -> Option {
45 | if other.is_int() {
46 | other.try_as_int().and_then(|s| (self as &PartialOrd).partial_cmp(&s))
47 | } else if other.is_real() {
48 | let val = *self as f64;
49 | other.try_as_real().and_then(|s| (&val as &PartialOrd).partial_cmp(&s))
50 | } else {
51 | None
52 | }
53 | }
54 | }
55 |
56 |
57 | impl IArithm for i64 {
58 | // todo Cow::Borrowed for Zero and One cases
59 | fn try_add<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_int().map(|s| { Arg::Owned(box (*self + s)) }) }
60 | fn try_sub<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_int().map(|s| { Arg::Owned(box (*self - s)) }) }
61 | fn try_mul<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_int().map(|s| { Arg::Owned(box (*self * s)) }) }
62 | fn try_div<'o>(&self, other: Arg<'o>) -> Option> { other.try_as_int().map(|s| { Arg::Owned(box (*self / s)) }) }
63 | }
64 |
--------------------------------------------------------------------------------
/src/types/map.rs:
--------------------------------------------------------------------------------
1 | use std::collections::hash_map::{HashMap, Keys, Values, Iter};
2 | use std::iter::Iterator;
3 |
4 | use super::abc::*;
5 |
6 |
7 | impl <'a> Type for HashMap> {
8 | fn to_bool(&self) -> bool { !self.is_empty() }
9 | }
10 |
11 | impl <'a> IClone for HashMap> {
12 | fn iclone<'b>(&self) -> Result, CloneError> {
13 | let cloned: HashMap> = HashMap::new();
14 | for (k, v) in self.iter() {
15 | cloned.insert(k, v.iclone()?);
16 | }
17 | Ok( Box::new(cloned) )
18 | }
19 | }
20 |
21 |
22 | impl <'a, 'b: 'a> IIterable<'a> for HashMap> {
23 | fn is_empty(&self) -> bool {
24 | HashMap::is_empty(self)
25 | }
26 |
27 | fn ivalues(&self) -> VIterator {
28 | VIterator { me: self.values() }
29 | }
30 | }
31 |
32 |
33 |
34 | //impl <'a> IMap for HashMap> {
35 | // fn ivalues(&self) -> Option>> {
36 | // Some(Box::new(VIterator { me: self.values() }))
37 | // }
38 | //// fn ikeys(&self) -> Option {
39 | //// Some(KIterator { me: self.keys() })
40 | //// }
41 | //// fn ikeyvalues(&self) -> Option {
42 | //// Some(KVIterator { me: self.iter() })
43 | //// }
44 | //}
45 |
46 |
47 |
48 | //impl <'a> Iterator for KIterator<'a> {
49 | // type Item = &'a EntityId;
50 | //
51 | // fn next(&mut self) -> Option<&'a EntityId> {
52 | // match self.me.next() {
53 | // Some(next) => Some(next),
54 | // None => None
55 | // }
56 | // }
57 | //}
58 | //
59 | //impl <'a> Iterator for KVIterator<'a> {
60 | // type Item = (&'a EntityId, &'a Var);
61 | //
62 | // fn next(&mut self) -> Option<(&'a EntityId, &'a Var)> {
63 | // match self.me.next() {
64 | // Some(next) => Some(next),
65 | // None => None
66 | // }
67 | // }
68 | //}
69 |
--------------------------------------------------------------------------------
/src/container/args.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 | use std::collections::HashMap;
3 | use std::convert::AsRef;
4 | use std::ops::Deref;
5 |
6 | use types::abc::Type;
7 |
8 |
9 | pub type EntityId<'a> = Cow<'a, str>;
10 | pub type Args<'a> = HashMap, Arg<'a>>;
11 |
12 |
13 | #[inline]
14 | pub fn ex<'r, A: Into>>(v: A) -> Arg<'r> {
15 | v.into()
16 | }
17 |
18 |
19 | #[derive(Debug)]
20 | pub enum Arg<'r> {
21 | Owned(Box Type<'t> + 'r>),
22 | Ref(&'r (for <'t> Type<'t> + 'r)),
23 | }
24 |
25 |
26 | impl <'r> Clone for Arg<'r> {
27 | fn clone(&self) -> Arg<'r> {
28 | match *self {
29 | Arg::Ref(b) => Arg::Ref(b),
30 | Arg::Owned(ref o) => o.clone_type(),
31 | }
32 | }
33 | }
34 |
35 |
36 | impl <'r> Arg<'r> {
37 | pub fn to_ref(&'r self) -> Arg<'r> {
38 | Arg::Ref(self.as_ref())
39 | }
40 |
41 | pub fn to_owned(&self) -> Arg<'static> {
42 | self.clone_type()
43 | }
44 |
45 | pub fn into_owned(self) -> Arg<'r> {
46 | match self {
47 | Arg::Owned(_) => self,
48 | Arg::Ref(_) => self.clone_type(),
49 | }
50 | }
51 | }
52 |
53 |
54 | impl <'r> Deref for Arg<'r> {
55 | type Target = for <'t> Type<'t> + 'r;
56 |
57 | fn deref(&self) -> &Self::Target {
58 | match *self {
59 | Arg::Owned(ref b) => b.deref(),
60 | Arg::Ref(r) => r,
61 | }
62 | }
63 | }
64 |
65 |
66 | impl <'r> AsRef Type<'t> + 'r> for Arg<'r> {
67 | fn as_ref(&self) -> &(for <'t> Type<'t> + 'r) {
68 | &**self
69 | }
70 | }
71 |
72 |
73 | impl <'r> From<&'r Arg<'r>> for Arg<'r> {
74 | fn from(v: &'r Arg<'r>) -> Arg<'r> {
75 | Arg::Ref(v.as_ref())
76 | }
77 | }
78 |
79 | impl <'r, T: for <'t> Type<'t> + 'r> From for Arg<'r> {
80 | fn from(v: T) -> Arg<'r> {
81 | Arg::Owned(box v)
82 | }
83 | }
84 |
85 | impl <'r> From<&'r (for <'t> Type<'t> + 'r)> for Arg<'r> {
86 | fn from(v: &'r (for <'t> Type<'t> + 'r)) -> Arg<'r> {
87 | Arg::Ref(v)
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/src/container/stack.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 |
3 | use abc::*;
4 | use {Args, Arg, Incrust, Template};
5 |
6 |
7 | pub type TemplateStack<'a> = Vec<&'a Template>;
8 |
9 |
10 | pub struct Stack<'a> {
11 | env: &'a Incrust,
12 | template_stack: Vec>,
13 | args: &'a Args<'a>,
14 | }
15 |
16 |
17 | pub struct VarContext<'a> {
18 | global: &'a Stack<'a>,
19 | parent: Option<&'a VarContext<'a>>,
20 | args: &'a Args<'a>,
21 | }
22 |
23 |
24 | impl <'a> Stack<'a> {
25 | pub fn new(env: &'a Incrust, template: Cow<'a, Template>, args: &'a Args<'a>) -> RenderResult {
26 | let mut stack = Stack { env, template_stack: vec![], args };
27 |
28 | let mut parent = Some(template);
29 | while let Some(template) = parent {
30 | parent = template.get_parent(&stack.top_scope())?.map(Cow::Owned);
31 | stack.template_stack.push(template);
32 | }
33 |
34 | Ok(stack)
35 | }
36 |
37 | pub fn top_scope(&'a self) -> VarContext<'a> {
38 | VarContext::new(self, self.args)
39 | }
40 |
41 | pub fn template(&'a self) -> &'a Template {
42 | self.template_stack.last().unwrap()
43 | }
44 |
45 | pub fn stack(&'a self) -> &'a [Cow<'a, Template>] {
46 | &self.template_stack
47 | }
48 |
49 | pub fn env(&self) -> &'a Incrust {
50 | self.env
51 | }
52 | }
53 |
54 |
55 | impl <'a> VarContext<'a> {
56 | pub fn new(global: &'a Stack<'a>, args: &'a Args<'a>) -> Self {
57 | VarContext { global, parent: None, args }
58 | }
59 |
60 | pub fn nested_scope(&'a self, args: &'a Args<'a>) -> Self {
61 | VarContext { global: self.global, parent: Some(self), args }
62 | }
63 |
64 | pub fn template(&self) -> &'a Template {
65 | self.global.template()
66 | }
67 |
68 | pub fn global(&self) -> &'a Stack<'a> {
69 | self.global
70 | }
71 |
72 | pub fn env(&self) -> &'a Incrust {
73 | self.global.env()
74 | }
75 |
76 | pub fn get(&self, id: &str) -> Option> {
77 | self.args.get(id).map(Arg::from)
78 | .or_else(|| self.parent
79 | .and_then(|p| p.get(id))
80 | .or_else(|| self.global.env().top_context().get(id).map(Arg::from))
81 | )
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/tests/loader.rs:
--------------------------------------------------------------------------------
1 | #[macro_use]
2 | extern crate maplit;
3 | extern crate incrust;
4 |
5 | use std::path::Path;
6 | use incrust::{Incrust, ex, Loader, FilesystemLoader, NamespaceLoader};
7 |
8 |
9 | #[test]
10 | fn dict() {
11 | let mut incrust = Incrust::new();
12 | incrust.loaders.push(Box::new(hashmap!{
13 | "1".into() => r#"{{ title | e }}
14 |
15 |
18 | {%- for fruit in fruits %}
19 | - {{ loop.index }}. {{ fruit | e }}
20 | {%- endfor %}
21 |
22 | {%- endif %}
23 |
24 | "#.into(),
25 | }));
26 | let sample_loader = FilesystemLoader::new(&Path::new("./assets/html/simple"));
27 |
28 | let sample_a = sample_loader.load("1-a.html").unwrap();
29 | let args = || hashmap!{
30 | "title".into() => ex("fruits"),
31 | "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")])
32 | };
33 |
34 | assert_eq!(sample_a, incrust.render("1", &args()).unwrap());
35 | }
36 |
37 | #[test]
38 | fn filesystem() {
39 | let mut incrust = Incrust::new();
40 | incrust.loaders.push(FilesystemLoader::new(&Path::new("./assets/tpl/simple")));
41 | let sample_loader = FilesystemLoader::new(&Path::new("./assets/html/simple"));
42 |
43 | let sample_a = sample_loader.load("1-a.html").unwrap();
44 | let args = hashmap!{
45 | "title".into() => ex("fruits"),
46 | "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")])
47 | };
48 |
49 | assert_eq!(sample_a, incrust.render("1", &args).unwrap());
50 | assert_eq!(sample_a, incrust.render("1.tpl", &args).unwrap());
51 | }
52 |
53 | #[test]
54 | fn namespace() {
55 | let mut incrust = Incrust::new();
56 | incrust.loaders.push(NamespaceLoader::new("simple:", FilesystemLoader::new(&Path::new("./assets/tpl/simple"))));
57 | let sample_loader = FilesystemLoader::new(&Path::new("./assets/html/simple"));
58 |
59 | let sample_a = sample_loader.load("1-a.html").unwrap();
60 | let args = hashmap!{
61 | "title".into() => ex("fruits"),
62 | "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")])
63 | };
64 |
65 | assert_eq!(sample_a, incrust.render("simple:1", &args).unwrap());
66 | assert_eq!(sample_a, incrust.render("simple:1.tpl", &args).unwrap());
67 | }
68 |
--------------------------------------------------------------------------------
/tests/compos.rs:
--------------------------------------------------------------------------------
1 | #![feature(box_syntax)]
2 | #![feature(specialization)]
3 |
4 | #[macro_use]
5 | extern crate maplit;
6 | extern crate incrust;
7 |
8 | use std::path::Path;
9 |
10 | use incrust::abc::EvalResult;
11 | use incrust::{Incrust, ex, Loader, FilesystemLoader, Type, Arg, Function, VarContext};
12 | use incrust::types::abc::{AsComposable, IComposable};
13 |
14 | #[derive(Debug, Clone)]
15 | struct Fruit {
16 | title: String,
17 | price: f64,
18 | }
19 |
20 | impl Fruit {
21 | pub fn new(title: &str, price: f64) -> Fruit { Fruit { title: title.to_owned(), price } }
22 | }
23 |
24 | impl <'t> Type<'t> for Fruit {
25 | fn clone_type(&self) -> Arg<'static> {
26 | Arg::Owned(box self.clone())
27 | }
28 | }
29 |
30 |
31 | impl AsComposable for Fruit {
32 | fn try_as_composable(&self) -> Option<&IComposable> { Some(self) }
33 | }
34 |
35 |
36 | impl IComposable for Fruit {
37 | fn get_attr(&self, id: &str) -> Option {
38 | match id {
39 | "title" => Some(ex(self.title.as_str())),
40 | "price" => Some(ex(self.price)),
41 | _ => None
42 | }
43 | }
44 | }
45 |
46 |
47 | #[test]
48 | fn attributes() {
49 | let mut incrust = Incrust::new();
50 | incrust.loaders.push(FilesystemLoader::new(&Path::new("./assets/tpl/simple")));
51 | let sample_loader = FilesystemLoader::new(&Path::new("./assets/html/simple"));
52 |
53 | let sample_a = sample_loader.load("2a.html").unwrap();
54 | let args = hashmap!{
55 | "title".into() => ex("fruits"),
56 | "fruits".into() => ex(vec![
57 | ex(Fruit::new("Orange", 4.0)),
58 | ex(Fruit::new("Apple", 2.5)),
59 | ex(Fruit::new("Banana", 2.25)),
60 | ])
61 | };
62 |
63 | assert_eq!(sample_a, incrust.render("2a", &args).unwrap());
64 | }
65 |
66 |
67 | #[test]
68 | fn invokables() {
69 | let mut incrust = Incrust::new();
70 | incrust.loaders.push(FilesystemLoader::new(&Path::new("./assets/tpl/simple")));
71 | let sample_loader = FilesystemLoader::new(&Path::new("./assets/html/simple"));
72 |
73 | fn title<'res, 'ctx>(_: &[Arg<'res>], _: &'ctx VarContext<'res>) -> EvalResult> {
74 | Ok(Some(ex("fruits")))
75 | }
76 |
77 | let sample_a = sample_loader.load("2a.html").unwrap();
78 | let args = hashmap!{
79 | "title".into() => Function::new(title),
80 | "fruits".into() => ex(vec![
81 | ex(Fruit::new("Orange", 4.0)),
82 | ex(Fruit::new("Apple", 2.5)),
83 | ex(Fruit::new("Banana", 2.25)),
84 | ])
85 | };
86 |
87 | assert_eq!(sample_a, incrust.render("2b", &args).unwrap());
88 | }
89 |
--------------------------------------------------------------------------------
/src/container/expression.rs:
--------------------------------------------------------------------------------
1 | #[derive(Debug, PartialEq, Clone)]
2 | pub struct Mustache {
3 | pub expr: FullExpression,
4 | }
5 |
6 | #[derive(Debug, PartialEq, Clone)]
7 | pub struct FullExpression {
8 | pub expr: DisjExpr,
9 | pub filters: Vec
10 | }
11 |
12 |
13 | #[derive(Debug, PartialEq, Clone)]
14 | pub enum ConjOp {
15 | And,
16 | }
17 |
18 | #[derive(Debug, PartialEq, Clone)]
19 | pub enum DisjOp {
20 | Or,
21 | }
22 |
23 | #[derive(Debug, PartialEq, Clone)]
24 | pub enum CmpOp {
25 | Lt,
26 | Lte,
27 | Eq,
28 | Neq,
29 | In,
30 | Nin,
31 | Gte,
32 | Gt,
33 | }
34 |
35 | #[derive(Debug, PartialEq, Clone)]
36 | pub enum SumOp {
37 | Add,
38 | Sub,
39 | }
40 |
41 | #[derive(Debug, PartialEq, Clone)]
42 | pub enum MulOp {
43 | Mul,
44 | Div,
45 | }
46 |
47 | #[derive(Debug, PartialEq, Clone)]
48 | pub struct DisjExpr {
49 | pub list: Vec,
50 | }
51 |
52 | #[derive(Debug, PartialEq, Clone)]
53 | pub struct ConjExpr {
54 | pub list: Vec,
55 | }
56 |
57 | #[derive(Debug, PartialEq, Clone)]
58 | pub struct CmpExpr {
59 | pub list: Vec,
60 | }
61 |
62 | #[derive(Debug, PartialEq, Clone)]
63 | pub struct CmpItem(pub CmpOp, pub Expr);
64 |
65 |
66 | #[derive(Debug, PartialEq, Clone)]
67 | pub struct Expr {
68 | pub sum: Vec,
69 | }
70 |
71 | #[derive(Debug, PartialEq, Clone)]
72 | pub struct ExprItem(pub SumOp, pub Term);
73 |
74 |
75 | #[derive(Debug, PartialEq, Clone)]
76 | pub struct Term {
77 | pub mul: Vec,
78 | }
79 |
80 | #[derive(Debug, PartialEq, Clone)]
81 | pub struct TermItem(pub MulOp, pub Factor);
82 |
83 |
84 | #[derive(Debug, PartialEq, Clone)]
85 | pub enum Factor {
86 | Invocation(Invocation),
87 | Index(Index),
88 | Attribute(Attribute),
89 | Variable(String),
90 | Literal(Literal),
91 | Subexpression(DisjExpr),
92 | }
93 |
94 | #[derive(Debug, PartialEq, Clone)]
95 | pub struct Attribute {
96 | pub id: String,
97 | pub on: Box,
98 | }
99 |
100 | #[derive(Debug, PartialEq, Clone)]
101 | pub struct Invocation {
102 | pub args: Vec,
103 | pub on: Box,
104 | }
105 |
106 | #[derive(Debug, PartialEq, Clone)]
107 | pub struct Index {
108 | pub index: Box,
109 | pub on: Box,
110 | }
111 |
112 | #[derive(Debug, PartialEq, Clone)]
113 | pub enum Literal {
114 | Char(char),
115 | Str(String),
116 | Int(i64),
117 | Real(f64),
118 | }
119 |
120 | #[derive(Debug, PartialEq, Clone)]
121 | pub enum FilterItem {
122 | Simple(String),
123 | }
124 |
125 |
--------------------------------------------------------------------------------
/src/parser/macros.rs:
--------------------------------------------------------------------------------
1 | #[macro_export]
2 | macro_rules! stmt_simple {
3 | ( $i:expr, $cmd: expr ) => ({
4 | use nom::multispace;
5 |
6 | do_parse!($i,
7 | tag!("{%") >>
8 | l: opt!(tag!("-")) >>
9 | many0!(multispace) >>
10 | tag!($cmd) >>
11 | many0!(multispace) >>
12 | r: opt!(tag!("-")) >>
13 | tag!("%}") >>
14 | ( SimpleStatement { strip_left: l.is_some(), strip_right: r.is_some() } )
15 | )
16 | });
17 | }
18 |
19 |
20 | #[macro_export]
21 | macro_rules! stmt_named {
22 | ( $i:expr, $cmd: expr ) => ({
23 | use nom::multispace;
24 | use parser::expressions::identifier;
25 |
26 | do_parse!($i,
27 | tag!("{%") >>
28 | l: opt!(tag!("-")) >>
29 | many0!(multispace) >>
30 | tag!($cmd) >>
31 | many0!(multispace) >>
32 | e: identifier >>
33 | many0!(multispace) >>
34 | r: opt!(tag!("-")) >>
35 | tag!("%}") >>
36 | ( NamedStatement { strip_left: l.is_some(), strip_right: r.is_some(), name: e } )
37 | )
38 | });
39 | }
40 |
41 |
42 | #[macro_export]
43 | macro_rules! stmt_expr {
44 | ( $i:expr, $cmd: expr ) => ({
45 | use nom::multispace;
46 | use parser::expressions::full_expression;
47 |
48 | do_parse!($i,
49 | tag!("{%") >>
50 | l: opt!(tag!("-")) >>
51 | many0!(multispace) >>
52 | tag!($cmd) >>
53 | many0!(multispace) >>
54 | e: full_expression >>
55 | many0!(multispace) >>
56 | r: opt!(tag!("-")) >>
57 | tag!("%}") >>
58 | ( ExprStatement { strip_left: l.is_some(), strip_right: r.is_some(), expression: e } )
59 | )
60 | });
61 | }
62 |
63 |
64 | /// `take_till!(T -> bool) => &[T] -> IResult<&[T], &[T]>`
65 | /// returns the longest list of bytes until the provided function succeeds
66 | ///
67 | /// The argument is either a function `&[T] -> bool` or a macro returning a `bool
68 | #[macro_export]
69 | macro_rules! take_till_slc (
70 | ($input:expr, $submac:ident!( $($args:tt)* )) => (
71 | {
72 | use nom::InputLength;
73 | match $input.iter().enumerate().position(|(i, _)| $submac!(&$input[i..], $($args)*)) {
74 | Some(n) => IResult::Done(&$input[n..], &$input[..n]),
75 | None => IResult::Done(&$input[($input).input_len()..], $input)
76 | }
77 | }
78 | );
79 | ($input:expr, $f:expr) => (
80 | take_till_slc!($input, call!($f));
81 | );
82 | );
83 |
--------------------------------------------------------------------------------
/src/parser/block_level.rs:
--------------------------------------------------------------------------------
1 | use std::str;
2 | #[allow(unused_imports)]
3 | use nom::{IResult, Err as NomErr, ErrorKind, alpha, alphanumeric, space, multispace};
4 |
5 | use container::expression::Mustache;
6 | use container::parsed::ParsedNode;
7 |
8 | use parser::statements::statement;
9 | use parser::statements::stmt_edge;
10 | use parser::expressions::full_expression;
11 |
12 |
13 | named!(pub text<&[u8], Vec >, terminated!( nodes, eof!() ) );
14 |
15 |
16 | pub fn nodes(input: &[u8]) -> IResult<&[u8], Vec > {
17 | let (i, list) = try_parse!(input, many0!(node) );
18 | IResult::Done(i, list)
19 | }
20 |
21 |
22 |
23 | named!(node<&[u8], ParsedNode>,
24 | alt!(
25 | plain_text |
26 | comment |
27 | mustache |
28 | statement
29 | )
30 | );
31 |
32 |
33 | fn comment(input: &[u8]) -> IResult<&[u8], ParsedNode> {
34 | let (i, (_, comment, _)) = try_parse!(input,
35 | tuple!(
36 | tag!("{#"),
37 | map_res!(
38 | take_until!("#}"),
39 | str::from_utf8
40 | ),
41 | tag!("#}")
42 | )
43 | );
44 | IResult::Done(i, ParsedNode::Comment(comment.to_owned()))
45 | }
46 |
47 |
48 | fn mustache(input: &[u8]) -> IResult<&[u8], ParsedNode> {
49 | do_parse!(input,
50 | tag!("{{") >>
51 | many0!(multispace) >>
52 | fe: full_expression >>
53 | many0!(multispace) >>
54 | tag!("}}") >>
55 | ( Mustache::new(fe).into() )
56 | )
57 | }
58 |
59 |
60 | fn plain_text(input: &[u8]) -> IResult<&[u8], ParsedNode> {
61 | fn try_brace<'a>(input: &'a [u8]) -> IResult<&[u8], &str> {
62 | let b = || -> IResult<&'a [u8], ()> {
63 | let _ = try_parse!(input, alt!( mustache | comment | stmt_edge ) );
64 | IResult::Done(input, ())
65 | };
66 | match b().is_done() {
67 | false => IResult::Done(&input[1..], "{"),
68 | true => IResult::Error(NomErr::Code(ErrorKind::Custom(0))),
69 | }
70 | }
71 |
72 | let (i, text) = try_parse!(input,
73 | do_parse!(
74 | v: many1!(
75 | alt!( map_res!( is_not!("{"), str::from_utf8 ) | try_brace )
76 | ) >>
77 | ( v.join("") )
78 | )
79 | );
80 | IResult::Done(i, ParsedNode::Text(text))
81 | }
82 |
83 |
84 |
85 | // ---------------------------------------------------------------------------
86 |
87 |
88 | //#[cfg(test)]
89 | //mod tests {
90 | // #![cfg_attr(feature = "cargo-clippy", allow(used_underscore_binding))]
91 | //
92 | // use nom::IResult::Done;
93 | //
94 | //}
95 |
--------------------------------------------------------------------------------
/src/types/string.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 | use std::cmp::Ordering;
3 |
4 | use types::abc::*;
5 | //use types::function::Function;
6 | use {Arg, ex};
7 |
8 |
9 | impl <'t> Type<'t> for String {
10 | fn clone_type(&self) -> Arg<'static> {
11 | Arg::Owned(box self.clone())
12 | }
13 | }
14 |
15 |
16 | impl AsBool for String {
17 | fn to_bool(&self) -> bool {
18 | !self.is_empty()
19 | }
20 | }
21 |
22 |
23 | impl AsString for String {
24 | fn is_string(&self) -> bool {
25 | true
26 | }
27 |
28 | fn try_as_string(&self) -> Option> {
29 | Some(Cow::Borrowed(self))
30 | }
31 | }
32 |
33 |
34 | impl IPartialEq for String {
35 | fn eq<'o>(&self, other: &'o Arg<'o>) -> bool {
36 | other.is_string() && other.try_as_string().map(|s| s.as_ref() == self).unwrap_or(false)
37 | }
38 | }
39 |
40 |
41 | impl IPartialOrd for String {
42 | fn partial_cmp<'o>(&self, other: &'o Arg<'o>) -> Option {
43 | if other.is_string() {
44 | other.try_as_string().and_then(|s| self.as_str().partial_cmp(s.as_ref()))
45 | } else {
46 | None
47 | }
48 | }
49 | }
50 |
51 |
52 | impl IArithm for String {
53 | fn try_add<'o> (&self, other: Arg<'o>) -> Option> {
54 | if self == "" {
55 | match other.is_string() {
56 | true => Some(other),
57 | false => other.try_as_string()
58 | .map(|s| ex(s.into_owned())),
59 | }
60 | } else {
61 | other.try_as_string()
62 | .map(move |s| ex(self.to_string() + s.as_ref()))
63 | }
64 | }
65 | }
66 |
67 |
68 | impl <'r> Into> for &'r str {
69 | fn into(self) -> Arg<'r> {
70 | ex(self.to_owned())
71 | // FIXME Arg::Ref(self)
72 | }
73 | }
74 |
75 |
76 | impl AsComposable for String {
77 | fn try_as_composable(&self) -> Option<&IComposable> {
78 | Some(self)
79 | }
80 | }
81 |
82 |
83 | impl IComposable for String {
84 | fn get_attr(&self, id: &str) -> Option {
85 | match id {
86 | "length" => Some(ex(self.len() as i64)),
87 | // "len" => Some(ex(Len(self))),
88 | // "len" => Some(Function::new(move |_args, _context| Ok(Some(box (self.len() as i64)))).into() )),
89 | _ => None
90 | }
91 | }
92 | }
93 |
94 |
95 | //use incrust::Context;
96 | //use abc::EvalResult;
97 | //
98 | //#[derive(Clone, Debug)]
99 | //struct Len<'a>(&'a str);
100 | //
101 | //impl <'aa> Type for Len<'aa> {
102 | // fn iclone<'a>(&self) -> BType<'a> {
103 | // box self.clone()
104 | // }
105 | //}
106 | //
107 | //impl <'a> Into> for Len<'a> {
108 | // fn into(self) -> BType<'a> {
109 | // box self
110 | // }
111 | //}
112 | //
113 | //impl <'a> IInvokable for Len<'a> {
114 | // fn invoke(&self, _args: &[BType], _context: &Context) -> EvalResult {
115 | // Ok(Some((self.0.len() as i64).into()))
116 | // }
117 | //}
118 |
119 |
--------------------------------------------------------------------------------
/src/renderer/abc.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 | use std::fmt;
3 |
4 | use abc::*;
5 | use {Arg, VarContext};
6 |
7 |
8 | pub type EvalResult = Result, EvalError>;
9 |
10 | #[derive(Debug)]
11 | pub enum EvalError {
12 | Invoke(InvokeError),
13 | NoneArg,
14 | NotComposable,
15 | NotIndexable,
16 | NotMappable,
17 | UnexpectedIndexType,
18 | AttributeNotExists(Cow<'static, str>),
19 | IndexNotExists(usize),
20 | KeyNotExists(Cow<'static, str>),
21 | Input(Cow<'static, str>),
22 | Process(Cow<'static, str>),
23 | }
24 |
25 |
26 | #[derive(Debug)]
27 | pub enum InvokeError {
28 | NotInvokable,
29 | WrongArgsNumber(usize, usize),
30 | WrongArgType(usize, ExpectedArgType),
31 | }
32 |
33 | #[derive(Debug)]
34 | pub enum ExpectedArgType {
35 | String,
36 | Int,
37 | Real,
38 | Bool
39 | }
40 |
41 | impl From for EvalError { fn from(err: InvokeError) -> Self { EvalError::Invoke(err) } }
42 |
43 |
44 | pub type FilterResult = Result, FilterError>;
45 |
46 | #[derive(Debug)]
47 | pub enum FilterError {
48 | UnknownFormatter(Cow<'static, str>),
49 | Input(Cow<'static, str>),
50 | Process(Cow<'static, str>),
51 | Format(fmt::Error),
52 | }
53 |
54 | impl From for FilterError { fn from(err: fmt::Error) -> Self { FilterError::Format(err) } }
55 |
56 |
57 | pub trait Filter: fmt::Debug + Send + Sync {
58 | fn filter<'s: 'a, 'a>(&'s self, context: &'a VarContext<'a>, value: Option>) -> FilterResult>;
59 | }
60 |
61 |
62 | pub type RenderResult = Result;
63 |
64 | #[derive(Debug)]
65 | pub enum RenderError {
66 | LoadTemplate(LoadError),
67 | ParseTemplate(TemplateParseError),
68 | VariableNotExists(Cow<'static, str>),
69 | EvalExpression(EvalError),
70 | Filter(FilterError),
71 | FunctionCallException(Cow<'static, str>),
72 | Format(fmt::Error),
73 | }
74 |
75 | impl From for RenderError { fn from(err: LoadError) -> Self { RenderError::LoadTemplate(err) } }
76 | impl From for RenderError { fn from(err: EvalError) -> Self { RenderError::EvalExpression(err) } }
77 | impl From for RenderError { fn from(err: TemplateParseError) -> Self { RenderError::ParseTemplate(err) } }
78 | impl From for RenderError { fn from(err: FilterError) -> Self { RenderError::Filter(err) } }
79 | impl From for RenderError { fn from(err: fmt::Error) -> Self { RenderError::Format(err) } }
80 |
81 |
82 | //quick_error! {
83 | // #[derive(Debug)]
84 | // pub enum RenderError {
85 | // LoadTemplate(err: LoadError) {
86 | // from()
87 | // },
88 | // EvalExpression(err: EvalError) {
89 | // from()
90 | // },
91 | // ParseTemplate(err: ParseError) {
92 | // from()
93 | // },
94 | // Filter(err: FilterError) {
95 | // from()
96 | // },
97 | // Format(err: fmt::Error) {
98 | // from()
99 | // },
100 | // VariableNotExists(err: String) {
101 | //
102 | // },
103 | // FunctionCallException(err: String) {
104 | //
105 | // },
106 | // }
107 | //}
108 |
--------------------------------------------------------------------------------
/src/container/parsed.rs:
--------------------------------------------------------------------------------
1 | use container::expression::*;
2 |
3 |
4 | pub type ParsedNodes = Vec;
5 |
6 |
7 | #[derive(Debug, PartialEq, Clone)]
8 | pub enum ParsedNode {
9 | Raw(ParsedRawStatement),
10 | Text(String),
11 | Comment(String),
12 | Mustache(Mustache),
13 | For(ParsedForStatement),
14 | If(ParsedIfStatement),
15 | Block(ParsedBlockStatement),
16 | Extends(ExprStatement),
17 | Include(ExprStatement),
18 | }
19 |
20 | #[derive(Debug, PartialEq, Clone)]
21 | pub struct SimpleStatement {
22 | pub strip_left: bool,
23 | pub strip_right: bool,
24 | }
25 |
26 | #[derive(Debug, PartialEq, Clone)]
27 | pub struct NamedStatement {
28 | pub strip_left: bool,
29 | pub strip_right: bool,
30 | pub name: String,
31 | }
32 |
33 | #[derive(Debug, PartialEq, Clone)]
34 | pub struct ExprStatement {
35 | pub strip_left: bool,
36 | pub strip_right: bool,
37 | pub expression: FullExpression,
38 | }
39 |
40 | #[derive(Debug, PartialEq, Clone)]
41 | pub struct ParsedRawStatement {
42 | pub begin: SimpleStatement,
43 | pub text: String,
44 | pub end: SimpleStatement,
45 | }
46 |
47 | #[derive(Debug, PartialEq, Clone)]
48 | pub struct ParsedIfBranch {
49 | pub begin: ExprStatement,
50 | pub block: ParsedNodes,
51 | }
52 |
53 | #[derive(Debug, PartialEq, Clone)]
54 | pub struct ParsedElseBranch {
55 | pub begin: SimpleStatement,
56 | pub block: ParsedNodes,
57 | }
58 |
59 | #[derive(Debug, PartialEq, Clone)]
60 | pub struct ParsedIfStatement {
61 | pub if_branches: Vec,
62 | pub else_branch: Option,
63 | pub end: SimpleStatement,
64 | }
65 |
66 | #[derive(Debug, PartialEq, Clone)]
67 | pub struct ParsedForStatement {
68 | pub begin: ExprStatement,
69 | pub block: ParsedNodes,
70 | pub key_var: Option,
71 | pub value_var: String,
72 | pub end: SimpleStatement,
73 | }
74 |
75 | #[derive(Debug, PartialEq, Clone)]
76 | pub struct ParsedBlockStatement {
77 | pub begin: NamedStatement,
78 | pub block: ParsedNodes,
79 | pub end: SimpleStatement,
80 | }
81 |
82 | // ---------------------------------------------------------------------------
83 |
84 | impl Default for SimpleStatement {
85 | fn default() -> Self {
86 | SimpleStatement {
87 | strip_left: false,
88 | strip_right: false,
89 | }
90 | }
91 | }
92 |
93 | impl Default for NamedStatement {
94 | fn default() -> Self {
95 | NamedStatement {
96 | strip_left: false,
97 | strip_right: false,
98 | name: Default::default(),
99 | }
100 | }
101 | }
102 |
103 | //impl Default for ExprStatement {
104 | // fn default() -> Self {
105 | // ExprStatement {
106 | // strip_left: false,
107 | // strip_right: false,
108 | // expression: None,
109 | // }
110 | // }
111 | //}
112 |
113 | impl Mustache { pub fn new(expr: FullExpression) -> Self { Mustache { expr } } }
114 | impl From for ParsedNode { fn from(v: Mustache) -> Self { ParsedNode::Mustache(v) } }
115 |
116 |
117 | impl FullExpression {
118 | pub fn new(expr: DisjExpr, filters: Vec) -> Self {
119 | FullExpression { expr, filters }
120 | }
121 | }
122 |
123 |
124 | impl From for Factor { fn from(v: Literal) -> Self { Factor::Literal(v) } }
125 | impl From for Factor { fn from(v: String) -> Self { Factor::Variable(v) } }
126 | impl From for Factor { fn from(v: DisjExpr) -> Self { Factor::Subexpression(v) } }
127 | impl From for Factor { fn from(v: Attribute) -> Self { Factor::Attribute(v) } }
128 | impl From for Factor { fn from(v: Invocation) -> Self { Factor::Invocation(v) } }
129 |
130 | impl From for ParsedNode { fn from(v: ParsedIfStatement) -> Self { ParsedNode::If(v) } }
131 | impl From for ParsedNode { fn from(v: ParsedForStatement) -> Self { ParsedNode::For(v) } }
132 | impl From for ParsedNode { fn from(v: ParsedBlockStatement) -> Self { ParsedNode::Block(v) } }
133 | impl From for ParsedNode { fn from(v: ParsedRawStatement) -> Self { ParsedNode::Raw(v) } }
134 |
--------------------------------------------------------------------------------
/src/renderer/renderer.rs:
--------------------------------------------------------------------------------
1 | use std::fmt;
2 |
3 | use abc::*;
4 | use container::expression::*;
5 | use container::template::*;
6 | use renderer::Writer;
7 | use {Arg, Args, VarContext};
8 |
9 | use super::eval_expr;
10 |
11 |
12 | pub fn text(context: &VarContext) -> RenderResult {
13 | let mut buffer = String::new();
14 | render_text(&mut buffer, context, context.template().root.as_slice())?;
15 | Ok(buffer)
16 | }
17 |
18 |
19 | pub fn render_text(writer: &mut W, context: &VarContext, nodes: &[Node]) -> RenderResult<()> {
20 | for x in nodes {
21 | match *x {
22 | Node::Text(ref txt) => write!(writer, "{}", txt)?,
23 | Node::Mustache(ref mus) => render_mustache(writer, context, mus)?,
24 | Node::For(ref stmt) => render_for(writer, context, stmt)?,
25 | Node::If(ref stmt) => render_if(writer, context, stmt)?,
26 | Node::Block(ref stmt) => render_block(writer, context, stmt)?,
27 | Node::Include(ref expr) => render_include(writer, context, expr)?,
28 | }
29 | }
30 | Ok(())
31 | }
32 |
33 |
34 | pub fn render_mustache(writer: &mut W, context: &VarContext, mus: &Mustache) -> RenderResult<()> {
35 | render_expression(writer, context, &mus.expr)
36 | }
37 |
38 |
39 | pub fn render_expression(writer: &mut W, context: &VarContext, expr: &FullExpression) -> RenderResult<()> {
40 | let mut acc = eval_expr(context, &expr.expr)?;
41 | for filter in &expr.filters {
42 | acc = match *filter {
43 | FilterItem::Simple(ref id) => context.env().filter(id, context, acc)?,
44 | };
45 | }
46 | match acc {
47 | None => write!(writer, "#None")?,
48 | Some(acc) => acc.render(&mut Writer(writer))?,
49 | }
50 | Ok(())
51 | }
52 |
53 |
54 | pub fn render_for(writer: &mut W, context: &VarContext, stmt: &ForStatement) -> RenderResult<()> {
55 | // FIXME implement instead: expression(&stmt.begin.expression, context)
56 | if let Some(value) = eval_expr(context, &stmt.expression.expr)? {
57 | if let Some(iterable) = value.try_as_iterable() {
58 | use container::cycle::LoopState;
59 | // TODO the "last" marker in a loop
60 | let mut state = LoopState::new(false);
61 | for v in iterable.ivalues() {
62 | {
63 | let local_scope: Args = hashmap! {
64 | stmt.value_var.as_str().into() => v.to_ref(),
65 | "loop".into() => Arg::Ref(&state),
66 | };
67 | render_text(writer, &context.nested_scope(&local_scope), &stmt.block)?;
68 | }
69 | state = state.next(false);
70 | }
71 | }
72 | };
73 | Ok(())
74 | }
75 |
76 |
77 | pub fn render_if(writer: &mut W, context: &VarContext, stmt: &IfStatement) -> RenderResult<()> {
78 | for branch in &stmt.if_branches {
79 | if let Some(res) = eval_expr(context, &branch.expr.expr)? {
80 | if res.to_bool() {
81 | render_text(writer, context, &branch.block)?;
82 | return Ok(());
83 | }
84 | }
85 | }
86 | if let Some(ref branch) = stmt.else_branch {
87 | render_text(writer, context, branch)?;
88 | }
89 | Ok(())
90 | }
91 |
92 |
93 | pub fn render_block(writer: &mut W, context: &VarContext, name: &str) -> RenderResult<()> {
94 | for template in context.global().stack() {
95 | if let Some(block) = template.blocks.get(name) {
96 | render_text(writer, context, block)?;
97 | break;
98 | };
99 | }
100 | Ok(())
101 | }
102 |
103 |
104 | pub fn render_include(writer: &mut W, context: &VarContext, expr: &FullExpression) -> RenderResult<()> {
105 | let name = eval_expr(context, &expr.expr)?
106 | .ok_or_else(|| LoadError::BadName("Can't evaluate name (None result)".into()))?;
107 | let name = name.try_as_string()
108 | .ok_or_else(|| LoadError::BadName("Name is not string".into()))?;
109 | let template = context.global().env().get_template(&name)?;
110 | // FIXME Base context
111 | // render_text(writer, &context.global().top_scope(), template.root.as_slice())
112 | // Current scope context
113 | render_text(writer, context, template.root.as_slice())
114 | }
115 |
--------------------------------------------------------------------------------
/src/types/list.rs:
--------------------------------------------------------------------------------
1 | use types::abc::*;
2 | use {Arg, ex};
3 |
4 |
5 | impl <'r, 't> Type<'t> for Vec> {
6 | // fn clone_type(&self) -> Arg<'static> {
7 | // Arg::Owned(box self.clone())
8 | // }
9 | fn clone_type(&self) -> Arg<'static> {
10 | Arg::Owned(
11 | box self.iter()
12 | .map(|v| (*v).clone_type())
13 | .collect::>>()
14 | )
15 | }
16 | }
17 |
18 | // todo resolve specialization conflict
19 | //impl IRender for Vec {
20 | // default fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result {
21 | // debug!("Default render for List {:?}", self);
22 | // write!(writer, "#List")
23 | // }
24 | //}
25 |
26 | impl <'r> AsBool for Vec> {
27 | fn to_bool(&self) -> bool {
28 | !self.is_empty()
29 | }
30 | }
31 |
32 | impl <'r> AsIterable for Vec> {
33 | fn try_as_iterable(&self) -> Option<&IIterable> {
34 | Some(self)
35 | }
36 | }
37 |
38 | impl <'r> AsComposable for Vec> {
39 | fn try_as_composable(&self) -> Option<&IComposable> {
40 | Some(self)
41 | }
42 | }
43 |
44 |
45 | impl <'r> IIterable for Vec> {
46 | fn is_empty(&self) -> bool {
47 | Vec::is_empty(self)
48 | }
49 |
50 | fn ivalues<'s: 'i, 'i>(&'s self) -> Box + 'i> {
51 | box self.iter().map(Arg::to_ref)
52 | }
53 | }
54 |
55 |
56 | impl <'r> IIndexable for Vec> {
57 | fn get_index(&self, index: usize) -> Option {
58 | self.get(index).map(Arg::to_ref)
59 | }
60 |
61 | fn len(&self) -> usize {
62 | Vec::len(self)
63 | }
64 |
65 | fn is_empty(&self) -> bool {
66 | Vec::is_empty(self)
67 | }
68 | }
69 |
70 |
71 | impl <'r> IComposable for Vec> {
72 | fn get_attr(&self, id: &str) -> Option {
73 | match id {
74 | "length" => Some(ex(self.len() as i64)),
75 | _ => None
76 | }
77 | }
78 | }
79 |
80 |
81 | //impl <'a> IIterable for Vec> {
82 | // fn ivalues<'b>(&self) -> Iterator> {
83 | // Some(Box::new(VIterator { me: self.iter() }))
84 | // }
85 | //}
86 | //
87 |
88 |
89 | //impl <'a> Iterator for KIterator<'a> {
90 | // type Item = &'a EntityId;
91 | //
92 | // fn next(&mut self) -> Option<&'a EntityId> {
93 | // match self.me.next() {
94 | // Some(next) => Some(next),
95 | // None => None
96 | // }
97 | // }
98 | //}
99 | //
100 | //impl <'a> Iterator for KVIterator<'a> {
101 | // type Item = (&'a EntityId, &'a Var);
102 | //
103 | // fn next(&mut self) -> Option<(&'a EntityId, &'a Var)> {
104 | // match self.me.next() {
105 | // Some(next) => Some(next),
106 | // None => None
107 | // }
108 | // }
109 | //}
110 |
111 |
112 | // --------------------------------------------------------------------------------------------------------------------
113 |
114 |
115 | impl <'r, 't> Type<'t> for &'r [Arg<'r>] {
116 | // fn clone_type(&self) -> Arg<'static> {
117 | // Arg::Owned(box self.clone())
118 | // }
119 | fn clone_type(&self) -> Arg<'static> {
120 | Arg::Owned(
121 | box self.iter()
122 | .map(|v| (*v).clone_type())
123 | .collect::>>()
124 | )
125 | }
126 | }
127 |
128 | // todo resolve specialization conflict
129 | //impl IRender for Vec {
130 | // default fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result {
131 | // debug!("Default render for List {:?}", self);
132 | // write!(writer, "#List")
133 | // }
134 | //}
135 |
136 | impl <'r> AsBool for &'r [Arg<'r>] {
137 | fn to_bool(&self) -> bool {
138 | !(*self).is_empty()
139 | }
140 | }
141 |
142 | impl <'r> AsIterable for &'r [Arg<'r>] {
143 | fn try_as_iterable(&self) -> Option<&IIterable> {
144 | Some(self)
145 | }
146 | }
147 |
148 | impl <'r> AsComposable for &'r [Arg<'r>] {
149 | fn try_as_composable(&self) -> Option<&IComposable> {
150 | Some(self)
151 | }
152 | }
153 |
154 |
155 | impl <'r> IIterable for &'r [Arg<'r>] {
156 | fn is_empty(&self) -> bool {
157 | (*self).is_empty()
158 | }
159 |
160 | fn ivalues<'s: 'i, 'i>(&'s self) -> Box + 'i> {
161 | box self.iter().map(Arg::to_ref)
162 | }
163 | }
164 |
165 |
166 | impl <'r> IIndexable for &'r [Arg<'r>] {
167 | fn get_index(&self, index: usize) -> Option {
168 | self.get(index).map(Arg::to_ref)
169 | }
170 |
171 | fn len(&self) -> usize {
172 | (*self).len()
173 | }
174 |
175 | fn is_empty(&self) -> bool {
176 | (*self).is_empty()
177 | }
178 | }
179 |
180 |
181 | impl <'r> IComposable for &'r [Arg<'r>] {
182 | fn get_attr(&self, id: &str) -> Option {
183 | match id {
184 | "length" => Some(ex(self.len() as i64)),
185 | _ => None
186 | }
187 | }
188 | }
189 |
--------------------------------------------------------------------------------
/src/types/abc.rs:
--------------------------------------------------------------------------------
1 | use std::any::Any;
2 | use std::borrow::Cow;
3 | use std::cmp::Ordering;
4 | use std::fmt;
5 | use std::iter::Iterator;
6 | use std::slice::Iter;
7 |
8 | use abc::EvalResult;
9 | use renderer::Writer;
10 | use Arg;
11 | use VarContext;
12 |
13 |
14 | // --------------------------------------------------------------------------------------------------------------------
15 |
16 | pub trait Type<'r>:
17 | AsString + AsBool + AsReal + AsInt + AsIterable +
18 | AsIndexable + AsMappable + AsComposable + AsInvokable +
19 | AsPartialEq + AsPartialOrd +
20 | IArithm + IRender + fmt::Debug + Send + Sync
21 | {
22 | fn clone_type(&self) -> Arg<'static>;
23 | }
24 |
25 | // --- [ try interfaces ] ---------------------------------------------------------------------------------------------
26 |
27 | pub trait IRender {
28 | fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result;
29 | }
30 |
31 | pub trait AsAny {
32 | fn try_as_any(&self) -> Option<&Any>;
33 | }
34 |
35 | pub trait AsString {
36 | fn is_string(&self) -> bool;
37 | fn try_as_string(&self) -> Option>;
38 | }
39 |
40 | pub trait AsBool {
41 | fn is_bool(&self) -> bool;
42 | fn to_bool(&self) -> bool;
43 | }
44 |
45 | pub trait AsReal {
46 | fn is_real(&self) -> bool;
47 | fn try_as_real(&self) -> Option;
48 | }
49 |
50 | pub trait AsInt {
51 | fn is_int(&self) -> bool;
52 | fn try_as_int(&self) -> Option;
53 | }
54 |
55 | pub trait AsInvokable {
56 | fn is_invokable(&self) -> bool;
57 | fn try_as_invokable(&self) -> Option<&IInvokable>;
58 | }
59 |
60 | pub trait AsIterable {
61 | fn is_iterable(&self) -> bool;
62 | fn try_as_iterable(&self) -> Option<&IIterable>;
63 | }
64 |
65 | pub trait AsComposable {
66 | fn is_composable(&self) -> bool;
67 | fn try_as_composable(&self) -> Option<&IComposable>;
68 | }
69 |
70 | pub trait AsIndexable {
71 | fn is_indexable(&self) -> bool;
72 | fn try_as_indexable(&self) -> Option<&IIndexable>;
73 | }
74 |
75 | pub trait AsMappable {
76 | fn is_mappable(&self) -> bool;
77 | fn try_as_mappable(&self) -> Option<&IMappable>;
78 | }
79 |
80 | pub trait AsPartialEq {
81 | fn is_partial_eq(&self) -> bool;
82 | fn try_as_partial_eq(&self) -> Option<&IPartialEq>;
83 | }
84 |
85 | pub trait AsPartialOrd {
86 | fn is_partial_ord(&self) -> bool;
87 | fn try_as_partial_ord(&self) -> Option<&IPartialOrd>;
88 | }
89 |
90 |
91 | // --- [ impl interfaces ] --------------------------------------------------------------------------------------------
92 |
93 | pub trait IArithm {
94 | fn try_add<'o>(&self, other: Arg<'o>) -> Option>;
95 | fn try_sub<'o>(&self, other: Arg<'o>) -> Option>;
96 | fn try_mul<'o>(&self, other: Arg<'o>) -> Option>;
97 | fn try_div<'o>(&self, other: Arg<'o>) -> Option>;
98 | }
99 |
100 | pub trait IInvokable {
101 | fn invoke<'r: 'a + 'c, 'a, 'c>(&self, args: &'a [Arg<'r>], context: &'c VarContext<'r>) -> EvalResult>;
102 | }
103 |
104 | pub trait IIterable {
105 | fn is_empty(&self) -> bool;
106 | fn ivalues<'s: 'i, 'i>(&'s self) -> Box + 'i>;
107 | }
108 |
109 | pub trait IIndexable {
110 | // fn has_index(&self, index: usize) -> bool;
111 | fn get_index(&self, index: usize) -> Option;
112 | fn is_empty(&self) -> bool;
113 | fn len(&self) -> usize;
114 | // fn as_slice(&self) -> &[Arg];
115 | }
116 |
117 | pub trait IComposable {
118 | fn get_attr(&self, id: &str) -> Option;
119 | // fn attrs(&self) -> &[BType];
120 | }
121 |
122 | pub trait IMappable {
123 | // fn has_key(&self, key: &str) -> bool;
124 | fn get_by_key(&self, key: &str) -> Option;
125 | fn is_empty(&self) -> bool;
126 | fn len(&self) -> usize;
127 | }
128 |
129 | pub trait IPartialEq {
130 | fn eq<'o>(&self, other: &'o Arg<'o>) -> bool;
131 | fn ne<'o>(&self, other: &'o Arg<'o>) -> bool { !self.eq(other) }
132 | }
133 |
134 | pub trait IPartialOrd {
135 | fn partial_cmp<'o>(&self, other: &'o Arg<'o>) -> Option;
136 | fn lt<'o>(&self, other: &'o Arg<'o>) -> Option {
137 | self.partial_cmp(other).map(|res| res == Ordering::Less)
138 | }
139 | fn le<'o>(&self, other: &'o Arg<'o>) -> Option {
140 | self.partial_cmp(other).map(|res| res != Ordering::Greater)
141 | }
142 | fn gt<'o>(&self, other: &'o Arg<'o>) -> Option {
143 | self.partial_cmp(other).map(|res| res == Ordering::Greater)
144 | }
145 | fn ge<'o>(&self, other: &'o Arg<'o>) -> Option {
146 | self.partial_cmp(other).map(|res| res != Ordering::Less)
147 | }
148 | }
149 |
150 |
151 | // --- [ feature interfaces ] -----------------------------------------------------------------------------------------
152 |
153 | pub struct VIterator<'r> {
154 | pub me: Iter<'r, Arg<'r>>,
155 | }
156 |
157 | impl <'r> Iterator for VIterator<'r> {
158 | type Item = &'r Arg<'r>;
159 |
160 | fn next(&mut self) -> Option {
161 | self.me.next()
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/src/types/defaults.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 | use std::fmt;
3 | use std::fmt::Display;
4 | use std::fmt::Write;
5 |
6 | use types::abc::*;
7 | use renderer::Writer;
8 | use Arg;
9 |
10 |
11 | // CHECK whether it is necessary
12 | //impl <'a, T> Type for &'a T where T: Type {
13 | //// fn iclone(&self) -> Arg {
14 | //// (*self as &Type).iclone()
15 | //// }
16 | //}
17 |
18 |
19 | // --- [ default implementations ] ------------------------------------------------------------------------------------
20 |
21 | impl <'r, T> IRender for T where T: for <'t> Type<'t> + 'r {
22 | default fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result {
23 | debug!("Default render for Type {:?}", self);
24 | write!(writer, "#Type")
25 | }
26 | }
27 |
28 | impl <'r, T> IRender for T where T: for <'t> Type<'t> + 'r + Display {
29 | default fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result {
30 | write!(writer, "{}", self)
31 | }
32 | }
33 |
34 | impl <'r, T> AsString for T where T: for <'t> Type<'t> + 'r {
35 | default fn is_string(&self) -> bool {
36 | false
37 | }
38 |
39 | default fn try_as_string(&self) -> Option> {
40 | None
41 | }
42 | }
43 |
44 | impl <'r, T> AsString for T where T: for <'t> Type<'t> + 'r + Display {
45 | default fn try_as_string(&self) -> Option> {
46 | Some(Cow::Owned(ToString::to_string(self)))
47 | }
48 | }
49 |
50 | impl <'r, T> AsBool for T where T: for <'t> Type<'t> + 'r {
51 | default fn is_bool(&self) -> bool {
52 | false
53 | }
54 | default fn to_bool(&self) -> bool {
55 | true
56 | }
57 | }
58 |
59 | impl <'r, T> AsReal for T where T: for <'t> Type<'t> + 'r {
60 | default fn is_real(&self) -> bool {
61 | false
62 | }
63 | default fn try_as_real(&self) -> Option {
64 | None
65 | }
66 | }
67 |
68 | impl <'r, T> AsInt for T where T: for <'t> Type<'t> + 'r {
69 | default fn is_int(&self) -> bool {
70 | false
71 | }
72 |
73 | default fn try_as_int(&self) -> Option {
74 | None
75 | }
76 | }
77 |
78 | impl <'r, T> AsIterable for T where T: for <'t> Type<'t> + 'r {
79 | default fn is_iterable(&self) -> bool {
80 | false
81 | }
82 |
83 | default fn try_as_iterable(&self) -> Option<&IIterable> {
84 | None
85 | }
86 | }
87 |
88 | impl <'r, T> AsIterable for T where T: for <'t> Type<'t> + 'r + IIterable {
89 | fn is_iterable(&self) -> bool {
90 | true
91 | }
92 |
93 | default fn try_as_iterable(&self) -> Option<&IIterable> {
94 | Some(self)
95 | }
96 | }
97 |
98 | impl <'r, T> AsIndexable for T where T: for <'t> Type<'t> + 'r {
99 | default fn is_indexable(&self) -> bool {
100 | false
101 | }
102 |
103 | default fn try_as_indexable(&self) -> Option<&IIndexable> {
104 | None
105 | }
106 | }
107 |
108 | impl <'r, T> AsIndexable for T where T: for <'t> Type<'t> + 'r + IIndexable {
109 | fn is_indexable(&self) -> bool {
110 | true
111 | }
112 |
113 | default fn try_as_indexable(&self) -> Option<&IIndexable> {
114 | Some(self)
115 | }
116 | }
117 |
118 | impl <'r, T> AsMappable for T where T: for <'t> Type<'t> + 'r {
119 | default fn is_mappable(&self) -> bool {
120 | false
121 | }
122 |
123 | default fn try_as_mappable(&self) -> Option<&IMappable> {
124 | None
125 | }
126 | }
127 |
128 | impl <'r, T> AsMappable for T where T: for <'t> Type<'t> + 'r + IMappable {
129 | fn is_mappable(&self) -> bool {
130 | true
131 | }
132 |
133 | default fn try_as_mappable(&self) -> Option<&IMappable> {
134 | Some(self)
135 | }
136 | }
137 |
138 | impl <'r, T> AsComposable for T where T: for <'t> Type<'t> + 'r {
139 | default fn is_composable(&self) -> bool {
140 | false
141 | }
142 |
143 | default fn try_as_composable(&self) -> Option<&IComposable> {
144 | None
145 | }
146 | }
147 |
148 | impl <'r, T> AsComposable for T where T: for <'t> Type<'t> + 'r + IComposable {
149 | fn is_composable(&self) -> bool {
150 | true
151 | }
152 |
153 | default fn try_as_composable(&self) -> Option<&IComposable> {
154 | Some(self)
155 | }
156 | }
157 |
158 | impl <'r, T> AsInvokable for T where T: for <'t> Type<'t> + 'r {
159 | default fn is_invokable(&self) -> bool {
160 | false
161 | }
162 |
163 | default fn try_as_invokable(&self) -> Option<&IInvokable> {
164 | None
165 | }
166 | }
167 |
168 | impl <'r, T> AsInvokable for T where T: for <'t> Type<'t> + 'r + IInvokable {
169 | fn is_invokable(&self) -> bool {
170 | true
171 | }
172 |
173 | default fn try_as_invokable(&self) -> Option<&IInvokable> {
174 | Some(self)
175 | }
176 | }
177 |
178 |
179 | impl <'r, T> AsPartialEq for T where T: for <'t> Type<'t> + 'r {
180 | default fn is_partial_eq(&self) -> bool {
181 | false
182 | }
183 |
184 | default fn try_as_partial_eq(&self) -> Option<&IPartialEq> {
185 | None
186 | }
187 | }
188 |
189 | impl <'r, T> AsPartialEq for T where T: for <'t> Type<'t> + 'r + IPartialEq {
190 | default fn is_partial_eq(&self) -> bool {
191 | true
192 | }
193 |
194 | default fn try_as_partial_eq(&self) -> Option<&IPartialEq> {
195 | Some(self)
196 | }
197 | }
198 |
199 | impl <'r, T> AsPartialOrd for T where T: for <'t> Type<'t> + 'r {
200 | default fn is_partial_ord(&self) -> bool {
201 | false
202 | }
203 |
204 | default fn try_as_partial_ord(&self) -> Option<&IPartialOrd> {
205 | None
206 | }
207 | }
208 |
209 | impl <'r, T> AsPartialOrd for T where T: for <'t> Type<'t> + 'r + IPartialOrd {
210 | default fn is_partial_ord(&self) -> bool {
211 | true
212 | }
213 |
214 | default fn try_as_partial_ord(&self) -> Option<&IPartialOrd> {
215 | Some(self)
216 | }
217 | }
218 |
219 |
220 | // -------------------------------------------------------------------------------------------------
221 |
222 |
223 | impl <'r, S> IArithm for S where S: for <'t> Type<'t> + 'r {
224 | default fn try_add<'o>(&self, _other: Arg<'o>) -> Option> { None }
225 | default fn try_sub<'o>(&self, _other: Arg<'o>) -> Option> { None }
226 | default fn try_mul<'o>(&self, _other: Arg<'o>) -> Option> { None }
227 | default fn try_div<'o>(&self, _other: Arg<'o>) -> Option> { None }
228 | }
229 |
--------------------------------------------------------------------------------
/src/parser/literals.rs:
--------------------------------------------------------------------------------
1 | use std::str;
2 | #[allow(unused_imports)]
3 | use nom::{IResult, Err as NomErr, ErrorKind, alpha, alphanumeric, space, multispace};
4 |
5 | use container::expression::Factor;
6 | use container::expression::Literal;
7 |
8 |
9 | pub fn literal(input: &[u8]) -> IResult<&[u8], Factor> {
10 | let (i, l) = try_parse!(input, alt!(lit_str | lit_char | lit_num) );
11 | IResult::Done(i, Factor::Literal(l))
12 | }
13 |
14 | // --------------------------------------------------------------------------------------------------------------------
15 |
16 | pub fn lit_num(input: &[u8]) -> IResult<&[u8], Literal> {
17 | let (i, s) = try_parse!(input, map_res!( is_a!("0123456789."), str::from_utf8 ) );
18 | match parse_int(s).or_else(|_| parse_float(s)) {
19 | Ok(res) => IResult::Done(i, res),
20 | Err(err) => IResult::Error(NomErr::Code(ErrorKind::Custom(err))),
21 | }
22 | }
23 |
24 | fn parse_float(s: &str) -> Result {
25 | let n: f64 = s.parse().map_err(|_| 1301_u32)?;
26 | Ok(Literal::Real(n))
27 | }
28 |
29 | fn parse_int(s: &str) -> Result {
30 | let n: i64 = s.parse().map_err(|_| 1302_u32)?;
31 | Ok(Literal::Int(n))
32 | }
33 |
34 | // ---------------------------------------------------------------------------
35 |
36 | fn lit_char(input: &[u8]) -> IResult<&[u8], Literal> {
37 | let (i, (_, s, _)) = try_parse!(input,
38 | tuple!(
39 | char!('\''),
40 | char_char_agg,
41 | char!('\'')
42 | )
43 | );
44 | trace!("lit_char {:?}", s);
45 | match parse_char(s.as_str()) {
46 | Ok(chr) => IResult::Done(i, Literal::Char(chr)),
47 | Err(err) => IResult::Error(NomErr::Code(ErrorKind::Custom(err))),
48 | }
49 | }
50 |
51 | named!(pub char_char_agg<&[u8], String>, do_parse!(
52 | c: many0!(alt!( char_escaped | char_char )) >>
53 | (c.join(""))
54 | ));
55 |
56 | named!(pub char_char<&[u8], &str>, map_res!( is_not!(r#"\'"#), str::from_utf8 ) );
57 |
58 | named!(pub char_escaped<&[u8], &str>, do_parse!(
59 | char!('\\') >>
60 | c: alt!(
61 | char!('\\') |
62 | char!('\'') |
63 | char!('"') |
64 | char!('t') |
65 | char!('r') |
66 | char!('n')
67 | ) >>
68 | (match c {
69 | '\\' => "\\",
70 | '\'' => "\'",
71 | '"' => "\"",
72 | 't' => "\t",
73 | 'r' => "\r",
74 | 'n' => "\n",
75 | _ => unreachable!()
76 | })
77 | ));
78 |
79 | fn parse_char(s: &str) -> Result {
80 | let mut i = s.chars();
81 | match (i.next(), i.next()) {
82 | (None, _) => Err(1303u32),
83 | (Some(c), None) => Ok(c),
84 | _ => Err(1304u32),
85 | }
86 | }
87 |
88 | // --------------------------------------------------------------------------------------------------------------------
89 |
90 | named!(pub lit_str<&[u8], Literal>, do_parse!(
91 | char!('"') >> s: str_char_agg >> char!('"') >>
92 | (Literal::Str(s))
93 | ));
94 |
95 | named!(pub str_char_agg<&[u8], String>, do_parse!(
96 | c: many0!(alt!( char_escaped | str_char )) >>
97 | (c.join(""))
98 | ));
99 |
100 | named!(pub str_char<&[u8], &str>, map_res!( is_not!(r#"\""#), str::from_utf8 ) );
101 |
102 | // --------------------------------------------------------------------------------------------------------------------
103 |
104 | #[cfg(test)]
105 | mod tests {
106 | use nom::IResult::Done;
107 |
108 | #[test]
109 | fn literal_str_char() {
110 | assert_eq!(Done(&b""[..], r#"\"#), super::char_escaped(br#"\\"#));
111 | assert_eq!(Done(&b""[..], r#"""#), super::char_escaped(br#"\""#));
112 | assert_eq!(Done(&b""[..], "\t"), super::char_escaped(br#"\t"#));
113 | assert_eq!(Done(&b""[..], "\r"), super::char_escaped(br#"\r"#));
114 | assert_eq!(Done(&b""[..], "\n"), super::char_escaped(br#"\n"#));
115 | }
116 |
117 | #[test]
118 | fn literal_str() {
119 | use container::expression::Literal::Str;
120 | assert_eq!(Done(&b""[..], Str(r#" {{ "#.into())), super::lit_str(br#"" {{ ""#));
121 | assert_eq!(Done(&b""[..], Str(r#" {{ "#.into()).into()), super::literal(br#"" {{ ""#));
122 | assert_eq!(Done(&b""[..], Str(r#"{{"#.into()).into()), super::literal(br#""{{""#));
123 | assert_eq!(Done(&b""[..], Str("New\nline".into()).into()), super::literal(br#""New\nline""#));
124 | assert_eq!(Done(&b""[..], Str(r#""Quotes""#.into()).into()), super::literal(br#""\"Quotes\"""#));
125 | }
126 |
127 | #[test]
128 | fn literal_char() {
129 | use container::expression::Literal::Char;
130 | assert_eq!("\\\\", r#"\\"#);
131 |
132 | assert_eq!(Done(&b""[..], r#"\"#), super::char_escaped(br#"\\"#));
133 |
134 | assert_eq!(Ok('\\'), super::parse_char("\\"));
135 | assert_eq!(Ok('\n'), super::parse_char("\n"));
136 |
137 | assert_eq!(Done(&b""[..], Char('\\')), super::lit_char(br#"'\\'"#));
138 | assert_eq!(Done(&b""[..], Char('\'')), super::lit_char(br#"'\''"#));
139 | assert_eq!(Done(&b""[..], Char('"') ), super::lit_char(br#"'\"'"#));
140 | assert_eq!(Done(&b""[..], Char('"') ), super::lit_char(br#"'"'"#));
141 | assert_eq!(Done(&b""[..], Char('\t')), super::lit_char(br#"'\t'"#));
142 | assert_eq!(Done(&b""[..], Char('\r')), super::lit_char(br#"'\r'"#));
143 | assert_eq!(Done(&b""[..], Char('\n')), super::lit_char(br#"'\n'"#));
144 | assert_eq!(Done(&b""[..], Char(' ') ), super::lit_char(br#"' '"#));
145 |
146 | assert!(super::lit_char(br#"''"#).is_err());
147 | assert!(super::lit_char(br#"' '"#).is_err());
148 | }
149 |
150 | #[test]
151 | fn literal_int() {
152 | use container::expression::Literal::Int;
153 | assert_eq!(Ok(Int(42)), super::parse_int("42"));
154 | assert_eq!(Done(&b""[..], Int(42)), super::lit_num(b"42"));
155 | assert_eq!(Done(&b""[..], Int(42).into()), super::literal(b"42"));
156 | }
157 |
158 | #[test]
159 | fn literal_real() {
160 | #![allow(clippy::approx_constant)]
161 | use container::expression::Literal::Real;
162 | assert_eq!(Ok(Real(3.141_592_6)), super::parse_float("3.1415926"));
163 | assert_eq!(Ok(Real(0.1)), super::parse_float(".1"));
164 | assert_eq!(Ok(Real(1.0)), super::parse_float("1."));
165 |
166 | assert_eq!(Done(&b""[..], Real(3.141_592_6)), super::lit_num(b"3.1415926"));
167 | assert_eq!(Done(&b""[..], Real(0.1)), super::lit_num(b".1"));
168 | assert_eq!(Done(&b""[..], Real(1.0)), super::lit_num(b"1."));
169 |
170 | assert_eq!(Done(&b""[..], Real(3.141_592_6).into()), super::literal(b"3.1415926"));
171 | assert_eq!(Done(&b""[..], Real(0.1).into()), super::literal(b".1"));
172 | assert_eq!(Done(&b""[..], Real(1.0).into()), super::literal(b"1."));
173 | }
174 | }
175 |
--------------------------------------------------------------------------------
/src/renderer/expression.rs:
--------------------------------------------------------------------------------
1 | use std::fmt;
2 |
3 | use abc::RenderResult;
4 | use VarContext;
5 | use container::expression::*;
6 |
7 |
8 | pub fn render_expr(writer: &mut W, context: &VarContext, expr: &DisjExpr) -> RenderResult<()> {
9 | let mut itr = expr.list.iter();
10 | match itr.next() {
11 | None => unreachable!(),
12 | Some(conj) => {
13 | render_conj(writer, context, conj)?;
14 | for conj in itr {
15 | write!(writer, " or ")?;
16 | render_conj(writer, context, conj)?;
17 | }
18 | Ok(())
19 | } } }
20 |
21 |
22 | pub fn render_conj(writer: &mut W, context: &VarContext, expr: &ConjExpr) -> RenderResult<()> {
23 | let mut itr = expr.list.iter();
24 | match itr.next() {
25 | None => unreachable!(),
26 | Some(cmp) => {
27 | render_cmp(writer, context, cmp)?;
28 | for cmp in itr {
29 | write!(writer, " and ")?;
30 | render_cmp(writer, context, cmp)?;
31 | }
32 | Ok(())
33 | } } }
34 |
35 |
36 | pub fn render_cmp(writer: &mut W, context: &VarContext, expr: &CmpExpr) -> RenderResult<()> {
37 | let mut itr = expr.list.iter();
38 | match itr.next() {
39 | None => unreachable!(),
40 | Some(&CmpItem(ref _op, ref sum)) => {
41 | render_sum(writer, context, sum)?;
42 | for &CmpItem(ref op, ref sum) in itr {
43 | let op = match *op {
44 | CmpOp::Lt => "<",
45 | CmpOp::Lte => "<=",
46 | CmpOp::Eq => "==",
47 | CmpOp::Neq => "!=",
48 | CmpOp::In => "in",
49 | CmpOp::Nin => "not in",
50 | CmpOp::Gte => ">=",
51 | CmpOp::Gt => ">",
52 | };
53 | write!(writer, " {} ", op)?;
54 | render_sum(writer, context, sum)?;
55 | }
56 | Ok(())
57 | } } }
58 |
59 |
60 | pub fn render_sum(writer: &mut W, context: &VarContext, expr: &Expr) -> RenderResult<()> {
61 | let mut itr = expr.sum.iter();
62 | match itr.next() {
63 | None => unreachable!(),
64 | Some(&ExprItem(ref _op, ref term)) => {
65 | render_prod(writer, context, term)?;
66 | for &ExprItem(ref op, ref term) in itr {
67 | let op = match *op {
68 | SumOp::Add => "+",
69 | SumOp::Sub => "-",
70 | };
71 | write!(writer, " {} ", op)?;
72 | render_prod(writer, context, term)?;
73 | }
74 | Ok(())
75 | } } }
76 |
77 |
78 | pub fn render_prod(writer: &mut W, context: &VarContext, term: &Term) -> RenderResult<()> {
79 | let mut itr = term.mul.iter();
80 | match itr.next() {
81 | None => unreachable!(),
82 | Some(&TermItem(ref _op, ref factor)) => {
83 | render_factor(writer, context, factor)?;
84 | for &TermItem(ref op, ref factor) in itr {
85 | let op = match *op {
86 | MulOp::Mul => "*",
87 | MulOp::Div => "/",
88 | };
89 | write!(writer, " {} ", op)?;
90 | render_factor(writer, context, factor)?;
91 | }
92 | Ok(())
93 | } } }
94 |
95 |
96 | pub fn render_factor(writer: &mut W, context: &VarContext, fctr: &Factor) -> RenderResult<()> {
97 | match *fctr {
98 | Factor::Literal(ref lit) => {
99 | render_literal(writer, lit)?;
100 | },
101 | Factor::Variable(ref id) => {
102 | write!(writer, "{}", id)?;
103 | },
104 | Factor::Subexpression(ref expr) => {
105 | write!(writer, "(")?;
106 | render_expr(writer, context, expr)?;
107 | write!(writer, ")")?;
108 | },
109 | Factor::Attribute(ref attr) => {
110 | render_factor(writer, context, &*attr.on)?;
111 | write!(writer, ".{}", attr.id)?;
112 | },
113 | Factor::Index(ref index) => {
114 | render_factor(writer, context, &*index.on)?;
115 | write!(writer, "[")?;
116 | render_expr(writer, context, &index.index)?;
117 | write!(writer, "]")?;
118 | },
119 | Factor::Invocation(ref inv) => {
120 | render_factor(writer, context, &*inv.on)?;
121 | write!(writer, "(")?;
122 | for (i, expr) in inv.args.iter().enumerate() {
123 | if i != 0 { write!(writer, ", ")?; }
124 | render_expr(writer, context, expr)?;
125 | }
126 | write!(writer, ")")?;
127 | },
128 | };
129 | Ok(())
130 | }
131 |
132 |
133 | pub fn render_literal(writer: &mut W, l: &Literal) -> RenderResult<()> {
134 | match *l {
135 | Literal::Str(ref string) => write!(writer, "{:?}", string)?,
136 | Literal::Char(ref chr) => write!(writer, "{:?}", chr)?,
137 | Literal::Int(ref int) => write!(writer, "{}", int)?,
138 | Literal::Real(ref real) => write!(writer, "{}", real)?,
139 | }
140 | Ok(())
141 | }
142 |
143 |
144 | #[cfg(test)]
145 | mod tests {
146 | #![allow(clippy::used_underscore_binding)]
147 | use std::fmt::Debug;
148 |
149 | use nom::IResult;
150 |
151 | use {Incrust, Args, ex, Template};
152 | use parser::expressions::expression as parse_expr;
153 |
154 | fn unwrap_iresult(result: IResult) -> T {
155 | match result {
156 | IResult::Done(_, v) => v,
157 | IResult::Error(e) => panic!("{:?}", e),
158 | IResult::Incomplete(i) => panic!("{:?}", i),
159 | }
160 | }
161 |
162 | #[test]
163 | fn eval_expr() {
164 | use super::render_expr;
165 |
166 | let args: Args = hashmap!{
167 | "the_one".into() => ex("World"),
168 | "one".into() => ex(1_i64),
169 | "two".into() => ex(2_i64),
170 | };
171 | let incrust = Incrust::default();
172 | let template = Template::default();
173 | let context = incrust.create_global_context(&template, &args).unwrap();
174 | let context = context.top_scope();
175 |
176 | let parse = |s| unwrap_iresult(parse_expr(s));
177 | let test = |s, b| {
178 | let mut buf = String::new();
179 | render_expr(&mut buf, &context, &parse(b)).unwrap();
180 | assert_eq!(s, buf)
181 | };
182 |
183 | test("1", b"1");
184 | test("1 + 1", b"1+1");
185 | test("1 + 1", b"1 + 1");
186 | test("1 - 1", b"1 \n -\t1");
187 |
188 | test("(1 / 1)", b"(1 / 1)");
189 | test("1 * 1", b"1 * 1");
190 | test("1 + 1 * 1", b"1 + 1 * 1");
191 | test("(1 + 1) * 1", b"(1 + 1) * 1");
192 | test("(1 + (1 / 1)) * 1", b"(1+(1/1))*1");
193 |
194 | test("True and False", b"True and False");
195 | test("0 or 1 and 2", b"0 or 1 and 2");
196 |
197 | test("1 == 1", b"1 == 1");
198 | test("1 != 1", b"1 != 1");
199 | test("1 <= 1", b"1 <= 1");
200 | test("1 >= 1", b"1 >= 1");
201 | test("1 < 1", b"1 < 1");
202 | test("1 > 1", b"1 > 1");
203 | }
204 | }
205 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 | [](https://crates.io/crates/incrust)
4 |
5 | [](https://travis-ci.org/alexander-irbis/incrust)
6 | 
7 | 
8 |
9 | ## {% Incrust %}
10 |
11 | > Incrust is a template engine inspired by Jinja2 and written in Rust.
12 |
13 | In fact it is a [Jinja2](http://jinja.pocoo.org/), [Django](https://docs.djangoproject.com/en/1.10/topics/templates/),
14 | [Twig](http://twig.sensiolabs.org/), [Swig](http://paularmstrong.github.io/swig/), [Liquid](https://shopify.github.io/liquid/)
15 | (and probably others) template engines constellation, which uses similar methodologies.
16 |
17 | ### Unstable
18 |
19 | The implementation is at a very early stage and the API is a subject of changes.
20 |
21 | __Note that Incrust currently requires the nightly version of the Rust compiler.__
22 |
23 |
24 | ## Installation
25 |
26 | Incrust is [available on crates.io](https://crates.io/crates/incrust) and can be included in your Cargo enabled project like this:
27 |
28 | ```toml
29 | [dependencies]
30 | incrust = "=0.2.15"
31 | ```
32 |
33 | For ease of use hashmaps you may use the [maplit](https://crates.io/crates/maplit)
34 |
35 | Then you need to setup your environment:
36 |
37 | ```rust
38 | #[macro_use]
39 | extern crate maplit;
40 | extern crate incrust;
41 |
42 | use incrust::ex;
43 |
44 | fn create_env() -> Incrust {
45 | use incrust::{Incrust, FilesystemLoader};
46 |
47 | let mut instance = Incrust::default();
48 | instance.loaders.push(FilesystemLoader::new("./assets/tpl"));
49 | instance
50 | }
51 |
52 | fn main() {
53 | let incrust = create_env();
54 | let args = hashmap!{ "name".into() => ex("World") };
55 | incrust.render("hello", &args).unwrap();
56 | }
57 | ```
58 |
59 | Though Incrust has smart loaders, it may be used just as advanced formatter to render directly from string template
60 |
61 | ```rust
62 | let args = hashmap!{ "name".into() => ex("World") };
63 | incrust.render_text("Hello, {{ name | e }}!", &args).unwrap();
64 | // or with prepared template
65 | let hello = incrust.parse("Hello, {{ name | e }}!");
66 | incrust.render_parsed(&hello, &args).unwrap();
67 | ```
68 |
69 |
70 | ## Syntax examples
71 |
72 | ### Comments
73 |
74 | ```twig
75 | Visible {# partially #} paragraph
76 | ```
77 | ```html
78 | Visible paragraph
79 | ```
80 |
81 | ### Escaping
82 |
83 | ```twig
84 | Example: {% raw %}{{ mustaches }}{% endraw %}
85 | ```
86 | ```html
87 | Example: {{ mustaches }}
88 | ```
89 |
90 | ### Literals
91 |
92 | ```twig
93 | Braces: {{ "{{" }}
94 | Pi: {{ 3.1415926 }}
95 | ```
96 | ```html
97 | Braces: {{
98 | Pi: 3.1415926
99 | ```
100 |
101 | ### Filters
102 |
103 | ```rust
104 | let args = hashmap!{ "title".into() => ex("") };
105 | ```
106 | ```twig
107 | {{ title | escape }}
108 | ```
109 | ```html
110 | <Cats & Dogs>
111 | ```
112 |
113 | ### Expressions
114 |
115 | ```rust
116 | let args = hashmap!{
117 | "what".into() => ex("Hello"),
118 | "who".into() => ex("World")
119 | };
120 | ```
121 | ```twig
122 | Say: "{{ what + ", " + who }}!"
123 | ```
124 | ```html
125 | Say: "Hello, World!"
126 | ```
127 |
128 | ```rust
129 | let args = hashmap!{
130 | "alpha".into() => ex(6isize),
131 | "omega".into() => ex(7f64)
132 | };
133 | ```
134 | ```twig
135 | The answer is {{ alpha * omega }}
136 | ```
137 | ```html
138 | The answer is 42
139 | ```
140 |
141 | ### Lazy boolean evaluation
142 |
143 | ```twig
144 | Amount: {{ amount and ("" + amount + " pcs") or "-" }}
145 | ```
146 | ```rust
147 | assert_eq!("Amount: 6 pcs", incrust.render("tpl", &hashmap!{ "amount".into() => ex(6isize) }).unwrap());
148 | assert_eq!("Amount: -", incrust.render("tpl", &hashmap!{ "amount".into() => ex(0isize) }).unwrap());
149 | ```
150 |
151 | ### Conditional statements
152 |
153 | ```twig
154 | String {% if "" %}has chars{% else %}is empty{% endif %}
155 | It's {% if False %}false{% elif True %}true{% endif %}
156 | ```
157 | ```html
158 | String is empty
159 | It's true
160 | ```
161 |
162 | ### For-Loop statements
163 |
164 | ```rust
165 | let args = hashmap!{ "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")]) };
166 | ```
167 | ```twig
168 |
169 | {%- for fruit in fruits %}
170 | - {{ loop.index }}. {{ fruit | e }}
171 | {%- endfor %}
172 |
173 | ```
174 | ```html
175 |
176 | - 1. Orange
177 | - 2. Apple
178 | - 3. Banana
179 |
180 | ```
181 |
182 |
183 | ### Template inheritance
184 |
185 | ```rust
186 | let args = hashmap!{ "parent_layout".into() => ex("default") };
187 | incrust.render("template", &args).unwrap()
188 | ```
189 | default.tpl
190 | ```twig
191 |
192 | {% block title %}Default title{% endblock %}
193 |
194 | {%- block body %}
195 | Default body
196 | {%- endblock %}
197 |
198 |
199 | ```
200 | template.tpl
201 | ```html
202 | {% extends parent_layout %}
203 | {% block title -%}
204 | New title
205 | {%- endblock %}
206 | ```
207 | Output
208 | ```html
209 |
210 | New title
211 |
212 | Default body
213 |
214 |
215 | ```
216 |
217 |
218 | ### Include
219 |
220 | ```rust
221 | let args = hashmap!{ "menu".into() => ex("default_menu") };
222 | assert_eq!(expected, incrust.render("tpl", &args).unwrap());
223 | ```
224 | default_menu.tpl
225 | ```twig
226 |
230 | ```
231 | template.tpl
232 | ```html
233 |
236 |
237 | Body
238 | ```
239 | Output
240 | ```html
241 |
247 |
248 | Body
249 | ```
250 |
251 |
252 | ## Alternatives
253 |
254 | If you are looking for a template engine for your project, you may also look at these projects.
255 |
256 | ### With a similar syntax
257 |
258 | * [cobalt-org/liquid-rust](https://github.com/cobalt-org/liquid-rust) Liquid templating for Rust
259 | * [colin-kiegel/twig-rust](https://github.com/colin-kiegel/twig-rust) Rust port of the twig-php template library
260 | * [Nercury/twig-rs](https://github.com/Nercury/twig-rs) The Twig templating engine for Rust (work in progress)
261 | * [Keats/tera](https://github.com/Keats/tera) A template engine for Rust
262 | * [djc/askama](https://github.com/djc/askama) Type-safe, compiled Jinja-like templates for Rust
263 |
264 |
265 | ### Others
266 |
267 | * [sunng87/handlebars-rust](https://github.com/sunng87/handlebars-rust) Rust templating with Handlebars
268 | * [nickel-org/rust-mustache](https://github.com/nickel-org/rust-mustache) Mustache template library for rust
269 |
270 |
271 | ## License
272 |
273 | This project is licensed under either of
274 | * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
275 | * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
276 | at your option.
277 |
278 |
279 | ### Contribution
280 |
281 | Unless you explicitly state otherwise, any contribution intentionally submitted
282 | for inclusion in the work by you, as defined in the Apache-2.0 license,
283 | shall be dual licensed as above, without any additional terms or conditions.
284 |
--------------------------------------------------------------------------------
/src/parser/statements.rs:
--------------------------------------------------------------------------------
1 | use std::str;
2 | #[allow(unused_imports)]
3 | use nom::{IResult, Err as NomErr, ErrorKind, alpha, alphanumeric, space, multispace};
4 |
5 | use container::expression::*;
6 | use container::parsed::*;
7 |
8 | use super::block_level::nodes;
9 |
10 |
11 | named!(pub statement<&[u8], ParsedNode>,
12 | alt!( if_block | for_block | raw_block | block_block | extends_block | include_block )
13 | );
14 |
15 | named!(pub stmt_edge<&[u8], ParsedNode>, do_parse!(
16 | tag!("{%") >> (ParsedNode::Text("".into()))
17 | ));
18 |
19 | // --------------------------------------------------------------------------------------------------------------------
20 |
21 | named!(pub stmt_raw<&[u8], SimpleStatement>, stmt_simple!("raw"));
22 | named!(pub stmt_endraw<&[u8], SimpleStatement>, stmt_simple!("endraw"));
23 |
24 | fn raw_block(input: &[u8]) -> IResult<&[u8], ParsedNode> {
25 | fn is_end(input: &[u8]) -> bool {
26 | stmt_endraw(input).is_done()
27 | }
28 | do_parse!(
29 | input,
30 | b: stmt_raw >>
31 | txt: map_res!(
32 | take_till_slc!(is_end),
33 | str::from_utf8
34 | ) >>
35 | e: stmt_endraw >>
36 | (ParsedRawStatement { begin: b, text: txt.into(), end: e }.into())
37 | )
38 | }
39 |
40 | // --------------------------------------------------------------------------------------------------------------------
41 |
42 | named!(pub stmt_for<&[u8], ExprStatement>, stmt_expr!("for"));
43 | named!(pub stmt_endfor<&[u8], SimpleStatement>, stmt_simple!("endfor"));
44 |
45 | named!(pub for_block<&[u8], ParsedNode>, do_parse!( s: for_statement >> (s.into()) ));
46 |
47 | pub fn for_statement(input: &[u8]) -> IResult<&[u8], ParsedForStatement> {
48 | fn finish(begin: ExprStatement, block: ParsedNodes, end: SimpleStatement) -> Option<(ParsedForStatement)> {
49 | let mut expr: DisjExpr = begin.expression.expr;
50 | if expr.list.len() != 1 {return None}
51 |
52 | let mut expr: ConjExpr = expr.list.remove(0);
53 | if expr.list.len() != 1 {return None}
54 |
55 | let mut expr: CmpExpr = expr.list.remove(0);
56 | if expr.list.len() != 2 {return None}
57 |
58 | let left = expr.list.remove(0);
59 | let right = expr.list.remove(0);
60 |
61 | match right.0 {
62 | CmpOp::In => {},
63 | _ => return None,
64 | }
65 |
66 | let mut expr: Expr = left.1;
67 | if expr.sum.len() != 1 {return None}
68 |
69 | let mut expr: Term = expr.sum.remove(0).1;
70 | if expr.mul.len() != 1 {return None}
71 |
72 | let left = expr.mul.remove(0).1;
73 |
74 | match left {
75 | Factor::Variable(value_var) => {
76 | let expression = FullExpression {
77 | filters: begin.expression.filters,
78 | expr: DisjExpr { list: vec![
79 | ConjExpr { list: vec![
80 | CmpExpr { list: vec![ right ] }
81 | ]}
82 | ]},
83 | };
84 | let begin = ExprStatement { expression, ..begin };
85 | Some(ParsedForStatement { begin, block, key_var: None, value_var, end })
86 | },
87 | _ => None
88 | }
89 | }
90 |
91 | let (i, (b, t, e)) = try_parse!(input, tuple!( stmt_for, nodes, stmt_endfor ) );
92 |
93 | match finish(b, t, e) {
94 | Some(result) => IResult::Done(i, result),
95 | None => IResult::Error(NomErr::Code(ErrorKind::Custom(1331))),
96 | }
97 | }
98 |
99 | // --------------------------------------------------------------------------------------------------------------------
100 |
101 | named!(pub stmt_if<&[u8], ExprStatement>, stmt_expr!("if"));
102 | named!(pub stmt_elif<&[u8], ExprStatement>, stmt_expr!("elif"));
103 | named!(pub stmt_else<&[u8], SimpleStatement>, stmt_simple!("else"));
104 | named!(pub stmt_endif<&[u8], SimpleStatement>, stmt_simple!("endif"));
105 |
106 | named!(pub if_block<&[u8], ParsedNode>, do_parse!( s: if_statement >> ( s.into() ) ));
107 |
108 | pub fn if_statement(input: &[u8]) -> IResult<&[u8], ParsedIfStatement> {
109 |
110 | named!(if_<&[u8], ParsedIfBranch>, do_parse!(
111 | begin: stmt_if >> block: nodes >> (ParsedIfBranch { begin, block })
112 | ));
113 | named!(elif<&[u8], ParsedIfBranch>, do_parse!(
114 | begin: stmt_elif >> block: nodes >> (ParsedIfBranch { begin, block })
115 | ));
116 | named!(else_<&[u8], ParsedElseBranch>, do_parse!(
117 | begin: stmt_else >> block: nodes >> (ParsedElseBranch { begin, block })
118 | ));
119 |
120 | do_parse!( input,
121 | if_branches: do_parse!(
122 | ifs: if_ >>
123 | elifs: many0!(elif) >>
124 | ({
125 | let mut list = elifs;
126 | list.insert(0, ifs);
127 | list
128 | })
129 | ) >>
130 | else_branch: opt!(else_) >>
131 | end: stmt_endif >>
132 | (ParsedIfStatement { if_branches, else_branch, end })
133 | )
134 | }
135 |
136 |
137 | // --------------------------------------------------------------------------------------------------------------------
138 |
139 | named!(pub stmt_block<&[u8], NamedStatement>, stmt_named!("block"));
140 | named!(pub stmt_endblock<&[u8], SimpleStatement>, stmt_simple!("endblock"));
141 |
142 | named!(pub block_block<&[u8], ParsedNode>, do_parse!( s: block_statement >> (s.into()) ));
143 |
144 | named!(pub block_statement<&[u8], ParsedBlockStatement>, do_parse!(
145 | begin: stmt_block >>
146 | block: nodes >>
147 | end: stmt_endblock >>
148 | (ParsedBlockStatement { begin, block, end })
149 | ));
150 |
151 |
152 | // --------------------------------------------------------------------------------------------------------------------
153 |
154 | named!(pub stmt_extends<&[u8], ExprStatement>, stmt_expr!("extends"));
155 |
156 | named!(pub extends_block<&[u8], ParsedNode>, do_parse!(
157 | s: stmt_extends >> (ParsedNode::Extends(s))
158 | ));
159 |
160 |
161 | // ---------------------------------------------------------------------------
162 |
163 | named!(pub stmt_include<&[u8], ExprStatement>, stmt_expr!("include"));
164 |
165 | named!(pub include_block<&[u8], ParsedNode>, do_parse!(
166 | s: stmt_include >> (ParsedNode::Include(s))
167 | ));
168 |
169 |
170 | // ---------------------------------------------------------------------------
171 |
172 | #[cfg(test)]
173 | mod tests {
174 | #![allow(clippy::used_underscore_binding)]
175 |
176 | use nom::IResult::Done;
177 | use container::expression::*;
178 | use container::parsed::*;
179 | use container::parsed::ParsedNode::*;
180 |
181 | #[test]
182 | fn statement() {
183 | use super::stmt_raw;
184 |
185 | let empty_statement = SimpleStatement::default();
186 | let strip_statement = SimpleStatement { strip_left: true, strip_right: true };
187 |
188 | let expected = |statement: &SimpleStatement| Done(&b""[..], statement.clone());
189 |
190 |
191 | assert_eq!(expected(&empty_statement), stmt_raw(b"{%raw%}"));
192 | assert_eq!(expected(&empty_statement), stmt_raw(b"{% raw %}"));
193 | assert_eq!(expected(&empty_statement), stmt_raw(b"{% raw %}"));
194 | assert_eq!(expected(&empty_statement), stmt_raw(b"{%\traw\t%}"));
195 | assert_eq!(expected(&empty_statement), stmt_raw(b"{%\nraw\n%}"));
196 | assert_eq!(expected(&empty_statement), stmt_raw(b"{%\rraw\r%}"));
197 |
198 | assert_eq!(expected(&strip_statement), stmt_raw(b"{%-raw-%}"));
199 | assert_eq!(expected(&strip_statement), stmt_raw(b"{%- raw -%}"));
200 | }
201 |
202 | #[test]
203 | fn raw() {
204 | use super::raw_block;
205 |
206 | let expected = |txt| {
207 | Done(&b""[..], Raw(
208 | ParsedRawStatement {
209 | begin: SimpleStatement { strip_left: false, strip_right: false },
210 | text: String::from(txt),
211 | end: SimpleStatement { strip_left: false, strip_right: false },
212 | }
213 | ))
214 | };
215 |
216 | assert_eq!(expected("{{ raw }}"), raw_block(b"{% raw %}{{ raw }}{% endraw %}"));
217 | assert_eq!(expected("{% if %}"), raw_block(b"{% raw %}{% if %}{% endraw %}"));
218 | assert_eq!(expected("{% if %}"), raw_block(b"{% raw %}{% if %}{% endraw %}"));
219 | }
220 |
221 | #[test]
222 | fn if_() {
223 | let sample = |strip_right| ParsedIfStatement {
224 | if_branches: vec![
225 | ParsedIfBranch {
226 | begin: ExprStatement {
227 | strip_left: false,
228 | strip_right: strip_right,
229 | expression: FullExpression {
230 | expr: DisjExpr {
231 | list: vec![ConjExpr {
232 | list: vec![CmpExpr {
233 | list: vec![CmpItem(CmpOp::Eq, Expr {
234 | sum: vec![ExprItem(SumOp::Add, Term {
235 | mul: vec![TermItem(MulOp::Mul, Factor::Variable("True".into()) )],
236 | })],
237 | })],
238 | }],
239 | }],
240 | },
241 | filters: Vec::new(),
242 | }
243 | },
244 | block: vec![Text("_".into())]
245 | }
246 | ],
247 | else_branch: None,
248 | end: SimpleStatement::default(),
249 | };
250 |
251 | assert_eq!(Done(&b""[..], sample(false)), super::if_statement(b"{% if True %}_{% endif %}"));
252 | assert_eq!(Done(&b""[..], sample(true)), super::if_statement(b"{% if True-%}_{% endif %}"));
253 | assert_eq!(Done(&b""[..], sample(true)), super::if_statement(b"{% if True -%}_{% endif %}"));
254 | }
255 |
256 | #[test]
257 | fn for_() {
258 | // TODO test for statement
259 | }
260 | }
261 |
--------------------------------------------------------------------------------
/src/container/template.rs:
--------------------------------------------------------------------------------
1 | use std::convert::AsRef;
2 | use std::borrow::Cow;
3 | use std::collections::HashMap;
4 |
5 | use abc::*;
6 | use container::expression::*;
7 | use container::parsed::{ParsedNodes, ParsedNode};
8 | use container::stack::VarContext;
9 |
10 |
11 | pub type Nodes = Vec;
12 |
13 |
14 | #[derive(Debug, Default, PartialEq, Clone)]
15 | pub struct Template {
16 | pub root: Nodes,
17 | pub blocks: HashMap, Nodes>,
18 | pub extends: Option,
19 | }
20 |
21 | impl AsRef for Template {
22 | fn as_ref(&self) -> &Template {
23 | self
24 | }
25 | }
26 |
27 | impl Template {
28 | pub fn parse(templ: &str) -> TemplateParseResult {
29 | use nom::IResult::*;
30 |
31 | let nodes = ::parser::text(templ.as_bytes());
32 | // trace!(" == parsed == {:?}", &parsed);
33 | match nodes {
34 | Incomplete(_) => unreachable!(),
35 | Error(err) => Err(TemplateParseError::Syntax(format!("{:?}", err).into())),
36 | Done(_, nodes) => Template::from_parsed(nodes),
37 | }
38 | }
39 |
40 | pub fn from_parsed(parsed: ParsedNodes) -> TemplateParseResult {
41 | fn process(templ: &mut Template, parsed: ParsedNodes, need_strip_first: bool, need_strip_last: bool) -> TemplateParseResult {
42 | let mut nodes: Nodes = Default::default();
43 |
44 | // TODO String
45 | struct TextCompleter {
46 | pub text: Vec,
47 | pub need_strip_left: bool,
48 | }
49 |
50 | impl TextCompleter {
51 | pub fn new(need_strip_left: bool) -> Self {
52 | TextCompleter {
53 | text: Default::default(),
54 | need_strip_left,
55 | }
56 | }
57 |
58 | fn prepare(&mut self, need_strip_right: bool) -> Option {
59 | if self.text.is_empty() {
60 | return None;
61 | }
62 |
63 | let txt: String = self.text.join("");
64 | self.text.clear();
65 |
66 | let txt: Cow = match (self.need_strip_left, need_strip_right) {
67 | (true, true) => txt.trim().into(),
68 | (true, false) => txt.trim_left().into(),
69 | (false, true) => txt.trim_right().into(),
70 | (false, false) => txt.into(),
71 | };
72 |
73 | if txt.is_empty() {
74 | None
75 | } else {
76 | Some(txt.into())
77 | }
78 | }
79 |
80 | pub fn complete(&mut self, nodes: &mut Nodes, need_strip_right: bool) {
81 | if let Some(txt) = self.prepare(need_strip_right) {
82 | nodes.push(Node::Text(txt));
83 | }
84 | self.need_strip_left = false;
85 | }
86 |
87 | pub fn compress(&mut self, need_strip_right: bool) {
88 | if !need_strip_right {
89 | return;
90 | }
91 | if let Some(txt) = self.prepare(need_strip_right) {
92 | self.text.push(txt);
93 | }
94 | }
95 | }
96 |
97 | let mut completer = TextCompleter::new(need_strip_first);
98 |
99 | for node in parsed {
100 | match node {
101 | ParsedNode::Comment(_) => {}, // Do nothing
102 | ParsedNode::Text(node) => {
103 | completer.text.push(node);
104 | },
105 | ParsedNode::Raw(node) => {
106 | completer.compress(node.begin.strip_left);
107 | completer.text.push(node.text);
108 | completer.need_strip_left = node.end.strip_right;
109 | },
110 | ParsedNode::Mustache(node) => {
111 | completer.complete(&mut nodes, false);
112 | completer.need_strip_left = false;
113 | nodes.push(node.into());
114 | },
115 | ParsedNode::For(node) => {
116 | completer.complete(&mut nodes, node.begin.strip_left);
117 | completer.need_strip_left = node.end.strip_right;
118 | nodes.push(ForStatement {
119 | expression: node.begin.expression,
120 | key_var: node.key_var,
121 | value_var: node.value_var,
122 | block: process(templ, node.block, node.begin.strip_right, node.end.strip_left)?,
123 | }.into());
124 | },
125 | ParsedNode::If(node) => {
126 | completer.complete(&mut nodes, node.if_branches[0].begin.strip_left);
127 | completer.need_strip_left = node.end.strip_right;
128 | let last_strip_left = match node.else_branch {
129 | Some(ref els) => [els.begin.strip_left],
130 | None => [node.end.strip_left]
131 | };
132 | let strip_left: Vec = node.if_branches.iter().skip(1)
133 | .map(|next| next.begin.strip_left)
134 | .chain(last_strip_left.iter().cloned())
135 | .collect();
136 | let mut if_branches = Vec::with_capacity(node.if_branches.len());
137 | for (branch, strip_left) in node.if_branches.into_iter().zip(strip_left.into_iter()) {
138 | if_branches.push(IfBranch {
139 | expr: branch.begin.expression,
140 | block: process(templ, branch.block, branch.begin.strip_right, strip_left)?,
141 | });
142 | }
143 | let else_branch = match node.else_branch {
144 | Some(branch) => Some(process(templ, branch.block, branch.begin.strip_right, node.end.strip_left)?),
145 | None => None,
146 | };
147 | nodes.push(IfStatement {
148 | if_branches,
149 | else_branch,
150 | }.into());
151 | },
152 | ParsedNode::Block(node) => {
153 | completer.complete(&mut nodes, node.begin.strip_left);
154 | completer.need_strip_left = node.end.strip_right;
155 | let block_nodes = process(templ, node.block, node.begin.strip_right, node.end.strip_left)?;
156 | templ.blocks.insert(node.begin.name.clone().into(), block_nodes);
157 | nodes.push(Node::Block(node.begin.name));
158 | },
159 | ParsedNode::Extends(stmt) => {
160 | if templ.extends.is_some() {
161 | Err(TemplateParseError::Syntax("Too many `extends` sections".into()))?;
162 | }
163 | completer.complete(&mut nodes, stmt.strip_left);
164 | completer.need_strip_left = stmt.strip_right;
165 | templ.extends = Some(stmt.expression);
166 | },
167 | ParsedNode::Include(stmt) => {
168 | completer.complete(&mut nodes, stmt.strip_left);
169 | completer.need_strip_left = stmt.strip_right;
170 | nodes.push(Node::Include(stmt.expression));
171 | },
172 | };
173 | }
174 |
175 | completer.complete(&mut nodes, need_strip_last);
176 | Ok(nodes)
177 | }
178 |
179 | let mut template = Template {
180 | root: Default::default(),
181 | blocks: Default::default(),
182 | extends: None,
183 | };
184 |
185 | template.root = process(&mut template, parsed, false, false)?;
186 |
187 | Ok(template)
188 | }
189 |
190 | pub fn get_parent(&self, context: &VarContext) -> RenderResult> {
191 | use ::renderer::evaluator::eval_expr;
192 |
193 | Ok(if let Some(fe) = self.extends.as_ref() {
194 | Some({
195 | let name = eval_expr(context, &fe.expr)?
196 | .ok_or_else(|| LoadError::BadName("Can't evaluate name (None result)".into()))?;
197 | let name = name.try_as_string()
198 | .ok_or_else(|| LoadError::BadName("Name is not string".into()))?;
199 | context.env().get_template(&name)?
200 | })
201 | } else {
202 | None
203 | })
204 | }
205 | }
206 |
207 |
208 | #[derive(Debug, PartialEq, Clone)]
209 | pub enum Node {
210 | Text(String),
211 | Mustache(Mustache),
212 | For(ForStatement),
213 | If(IfStatement),
214 | Block(String),
215 | Include(FullExpression),
216 | }
217 |
218 |
219 | #[derive(Debug, PartialEq, Clone)]
220 | pub struct IfBranch {
221 | pub expr: FullExpression,
222 | pub block: Nodes,
223 | }
224 |
225 |
226 | #[derive(Debug, PartialEq, Clone)]
227 | pub struct IfStatement {
228 | pub if_branches: Vec,
229 | pub else_branch: Option,
230 | }
231 |
232 |
233 | #[derive(Debug, PartialEq, Clone)]
234 | pub struct ForStatement {
235 | pub expression: FullExpression,
236 | pub block: Nodes,
237 | pub key_var: Option,
238 | pub value_var: String,
239 | }
240 |
241 | impl From for Node { fn from(v: Mustache) -> Self { Node::Mustache(v) } }
242 |
243 | impl From for Node { fn from(v: IfStatement) -> Self { Node::If(v) } }
244 | impl From for Node { fn from(v: ForStatement) -> Self { Node::For(v) } }
245 |
--------------------------------------------------------------------------------
/src/container/incrust.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::Cow;
2 | use std::collections::HashMap;
3 |
4 | use abc::*;
5 | use loader::GroupLoader;
6 | use {Args, Arg, ex, Stack, VarContext, Template};
7 |
8 |
9 | #[derive(Debug)]
10 | pub struct Incrust {
11 | pub loaders: GroupLoader,
12 | pub filters: HashMap, Box>,
13 | top_context: HashMap, Arg<'static>>,
14 | }
15 |
16 |
17 | impl Default for Incrust {
18 | fn default() -> Self {
19 | use ::filter::*;
20 |
21 | let mut filters: HashMap, Box> = HashMap::new();
22 |
23 | filters.insert("e".into(), box Escape);
24 | filters.insert("escape".into(), box Escape);
25 | filters.insert("unescape".into(), box Unescape);
26 |
27 | filters.insert("html_escape".into(), box Escape);
28 | filters.insert("html_unescape".into(), box Unescape);
29 | filters.insert("url_escape".into(), box UrlEscape);
30 | filters.insert("url_unescape".into(), box UrlUnescape);
31 |
32 | filters.insert("nl2spc".into(), box NewlineToSpace);
33 | filters.insert("newline_to_space".into(), box NewlineToSpace);
34 |
35 | let env = hashmap!{
36 | "True".into() => ex(true),
37 | "true".into() => ex(true),
38 | "False".into() => ex(false),
39 | "false".into() => ex(false),
40 | };
41 |
42 | Incrust {
43 | loaders: Vec::new(),
44 | filters,
45 | top_context: env,
46 | }
47 | }
48 | }
49 |
50 | impl Incrust {
51 | pub fn new() -> Self { Incrust::default() }
52 |
53 | pub fn no_default() -> Self {
54 | Incrust {
55 | loaders: Vec::new(),
56 | filters: HashMap::new(),
57 | top_context: HashMap::new(),
58 | }
59 | }
60 |
61 | pub fn top_context(&self) -> &HashMap, Arg> {
62 | &self.top_context
63 | }
64 |
65 | pub fn load(&self, name: &str) -> LoadResult {
66 | for loader in &self.loaders {
67 | if let Ok(template) = loader.load(name) {
68 | return Ok(template)
69 | }
70 | }
71 | Err(LoadError::NotFound)
72 | }
73 |
74 | pub fn filter<'s>(&'s self, id: &str, context: &'s VarContext<'s>, value: Option>) -> FilterResult> {
75 | match self.filters.get(id) {
76 | Some(filter) => filter.filter(context, value),
77 | None => Err(FilterError::UnknownFormatter(id.to_owned().into()))
78 | }
79 | }
80 |
81 | pub fn parse(&self, template: &str) -> TemplateParseResult {
82 | Template::parse(template)
83 | }
84 |
85 | pub fn get_template(&self, name: &str) -> RenderResult {
86 | Ok(self.parse(self.load(name)?.as_ref())?)
87 | }
88 |
89 | pub fn render<'r>(&self, name: &str, args: &'r Args<'r>) -> RenderResult {
90 | self.render_text(&self.load(name)?, args)
91 | }
92 |
93 | pub fn render_text<'r>(&self, text: &str, args: &'r Args<'r>) -> RenderResult {
94 | self.render_parsed(&self.parse(text)?, args)
95 | }
96 |
97 | pub fn render_parsed<'r>(&self, template: &Template, args: &'r Args<'r>) -> RenderResult {
98 | let global = self.create_global_context(template, args)?;
99 | let local = global.top_scope();
100 | self.render_prepared(&local)
101 | }
102 |
103 | pub fn render_prepared<'r>(&self, context: &'r VarContext<'r>) -> RenderResult {
104 | ::renderer::text(context)
105 | .map_err(|err| {
106 | debug!("Render error: {:?}", err);
107 | err
108 | })
109 | }
110 |
111 | pub fn create_global_context<'s>(&'s self, template: &'s Template, args: &'s Args<'s>) -> RenderResult> {
112 | Stack::new(self, Cow::Borrowed(template), args)
113 | }
114 | }
115 |
116 |
117 | #[cfg(test)]
118 | mod tests {
119 | #![allow(clippy::used_underscore_binding)]
120 | use super::*;
121 |
122 | #[test]
123 | fn text() {
124 | let incrust = Incrust::new();
125 | let templ = "Hello, World!";
126 | let expected = "Hello, World!";
127 | let result = incrust.render_text(templ, &Default::default()).unwrap();
128 | assert_eq!(result, expected);
129 | }
130 |
131 | #[test]
132 | fn comments() {
133 | let incrust = Incrust::new();
134 | let templ = incrust.parse("Visible {# partially #} paragraph
").unwrap();
135 | let expected = "Visible paragraph
";
136 | let result = incrust.render_parsed(&templ, &Default::default()).unwrap();
137 | assert_eq!(result, expected);
138 | }
139 |
140 | #[test]
141 | fn mustache() {
142 | let templ = "Hello, {{name}}!";
143 | let expected = "Hello, World!";
144 | let incrust = Incrust::new();
145 | let args = hashmap!{ "name".into() => ex("World") };
146 | let result = incrust.render_text(templ, &args).unwrap();
147 | assert_eq!(result, expected);
148 | }
149 |
150 | #[test]
151 | fn filter() {
152 | let templ = "";
153 | let args: Args = hashmap!{ "html".into() => ex("Hello, World!
") };
154 | let expected = "";
155 | let incrust = Incrust::new();
156 | let result = incrust.render_text(templ, &args).unwrap();
157 | assert_eq!(result, expected);
158 | }
159 |
160 | #[test]
161 | fn literal() {
162 | let incrust = Incrust::new();
163 | let args = Default::default();
164 | assert_eq!("Braces: {{", incrust.render_text(r#"Braces: {{ "{{" }}"#, &args).unwrap());
165 | assert_eq!("The answer: 42", incrust.render_text(r#"The answer: {{ 42 }}"#, &args).unwrap());
166 | assert_eq!("Pi: 3.1415926", incrust.render_text(r#"Pi: {{ 3.1415926 }}"#, &args).unwrap());
167 | }
168 |
169 | #[test]
170 | fn expression() {
171 | let incrust = Incrust::new();
172 | let args = hashmap!{
173 | "what".into() => ex("Hello"),
174 | "who".into() => ex("World")
175 | };
176 | assert_eq!(r#"Say: "Hello, World!""#, incrust.render_text(r#"Say: "{{ what + ", " + who }}!""#, &args).unwrap());
177 | let args = hashmap!{
178 | "alpha".into() => ex(6_i64),
179 | "omega".into() => ex(7_f64)
180 | };
181 | assert_eq!("The answer is 42", incrust.render_text(r#"The answer is {{ alpha * omega }}"#, &args).unwrap());
182 |
183 | let args = hashmap!{ "amount".into() => ex(6_i64) };
184 | assert_eq!("1 + 1 = 2", incrust.render_text(r#"1 + 1 = {{ 1 + 1 }}"#, &args).unwrap());
185 | assert_eq!("Amount: 6 pcs", incrust.render_text(r#"Amount: {{ amount and ("" + amount + " pcs") or "-" }}"#, &args).unwrap());
186 |
187 | let args = hashmap!{ "amount".into() => ex(0_i64) };
188 | assert_eq!("Amount: -", incrust.render_text(r#"Amount: {{ amount and ("" + amount + " pcs") or "-" }}"#, &args).unwrap());
189 | }
190 |
191 | #[test]
192 | fn if_statement() {
193 | let incrust = Incrust::new();
194 | let test = |expected, template| assert_eq!(expected, incrust.render_text(template, &Default::default()).unwrap());
195 | test("Mode: on", r#"Mode: {% if True %}on{% endif %}"#);
196 | test("String is empty", r#"String {% if "" %}has chars{% else %}is empty{% endif %}"#);
197 | test("String is true", r#"String {% if "" %}has chars{% elif True %}is true{% else %}is empty{% endif %}"#);
198 | }
199 |
200 | #[test]
201 | fn for_statement() {
202 | let incrust = Incrust::new();
203 | let args = hashmap!{ "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")]) };
204 | let tpl = r#"
205 |
206 | {%- for fruit in fruits %}
207 | - {{ loop.index }}. {{ fruit | e }}
208 | {%- endfor %}
209 |
210 | "#;
211 | let expected = r#"
212 |
213 | - 1. Orange
214 | - 2. Apple
215 | - 3. Banana
216 |
217 | "#;
218 | assert_eq!(expected, incrust.render_text(tpl, &args).unwrap());
219 | }
220 |
221 | #[test]
222 | fn block_statement() {
223 | let incrust = Incrust::new();
224 | let args = hashmap!{ "fruits".into() => ex(vec![ex("Orange"), ex("Apple"), ex("Banana")]) };
225 | let tpl = r#"
226 |
227 | {% block title %}Default title{% endblock %}
228 |
229 | "#;
230 | let expected = r#"
231 |
232 | Default title
233 |
234 | "#;
235 | assert_eq!(expected, incrust.render_text(tpl, &args).unwrap());
236 | }
237 |
238 | #[test]
239 | fn inheritance() {
240 | let base = r#"
241 |
242 | {% block title %}Default title{% endblock %}
243 |
244 | {%- block body %}
245 | Default body
246 | {%- endblock %}
247 |
248 |
249 | "#;
250 | let tpl = r#"
251 | {% extends parent_layout %}
252 | {% block title -%}
253 | New title
254 | {%- endblock %}
255 | "#;
256 |
257 | let expected = r#"
258 |
259 | New title
260 |
261 | Default body
262 |
263 |
264 | "#;
265 |
266 | let mut incrust = Incrust::new();
267 | incrust.loaders.push(box hashmap!{
268 | "base".into() => base.into(),
269 | "tpl".into() => tpl.into(),
270 | });
271 |
272 | let args = hashmap!{ "parent_layout".into() => ex("base") };
273 | assert_eq!(expected, incrust.render("tpl", &args).unwrap());
274 | }
275 |
276 | #[test]
277 | fn include() {
278 | let default_menu = r#"
279 |
283 | "#;
284 | let tpl = r#"
285 |
288 |
289 | Body
290 | "#;
291 |
292 | let expected = r#"
293 |
299 |
300 | Body
301 | "#;
302 |
303 | let mut incrust = Incrust::new();
304 | incrust.loaders.push(box hashmap!{
305 | "default_menu".into() => default_menu.into(),
306 | "tpl".into() => tpl.into(),
307 | });
308 |
309 | let args = hashmap!{ "menu".into() => ex("default_menu") };
310 | assert_eq!(expected, incrust.render("tpl", &args).unwrap());
311 | }
312 | }
313 |
--------------------------------------------------------------------------------
/LICENSE-APACHE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "[]"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright [yyyy] [name of copyright owner]
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
--------------------------------------------------------------------------------
/src/parser/expressions.rs:
--------------------------------------------------------------------------------
1 | use std::str;
2 | #[allow(unused_imports)]
3 | use nom::{IResult, alpha, alphanumeric, space, multispace};
4 |
5 | use container::expression::*;
6 |
7 | use parser::literals::literal;
8 |
9 |
10 | // ---------------------------------------------------------------------------
11 |
12 | named!(pub full_expression<&[u8], FullExpression>, do_parse!(
13 | expr: expression >>
14 | filters: filter_agg >>
15 | ( FullExpression::new(expr, filters) )
16 | ));
17 |
18 | // ---------------------------------------------------------------------------
19 |
20 | named!(pub filter_agg<&[u8], Vec >, many0!(do_parse!(
21 | many0!(multispace) >>
22 | f: filter >>
23 | (f)
24 | )));
25 |
26 |
27 | named!(pub filter<&[u8], FilterItem>, do_parse!(
28 | char!('|') >>
29 | opt!(multispace) >>
30 | id: identifier >>
31 | ( FilterItem::Simple(id) )
32 | ));
33 |
34 | // ---------------------------------------------------------------------------
35 |
36 | named!(pub identifier<&[u8], String>, do_parse!(
37 | res: map_res!(
38 | recognize!(do_parse!(alpha >> many0!(alt!(tag!("_") | alphanumeric)) >> () )),
39 | str::from_utf8
40 | ) >>
41 | ( res.to_string() )
42 | ));
43 |
44 | // ---------------------------------------------------------------------------
45 |
46 | named!(pub expression<&[u8], DisjExpr>, do_parse!(
47 | a: conj >>
48 | b: many0!(do_parse!(op_disj_bin >> c: conj >> (c))) >>
49 | ( {
50 | let mut list = b;
51 | list.insert(0, a);
52 | DisjExpr { list }
53 | } )
54 | ));
55 |
56 | named!(pub conj<&[u8], ConjExpr>, do_parse!(
57 | a: cmp >>
58 | b: many0!(do_parse!(op_conj_bin >> c: cmp >> (c))) >>
59 | ( {
60 | let mut list = b;
61 | list.insert(0, a);
62 | ConjExpr { list }
63 | } )
64 | ));
65 |
66 | named!(pub cmp<&[u8], CmpExpr>, do_parse!(
67 | a: do_parse!(op: value!(CmpOp::Eq) >> t: sum >> ( CmpItem(op, t) )) >>
68 | b: many0!(do_parse!(op: op_cmp_bin >> t: sum >> ( CmpItem(op, t) )) ) >>
69 | ( {
70 | let mut list = b;
71 | list.insert(0, a);
72 | CmpExpr { list }
73 | } )
74 | ));
75 |
76 | named!(pub sum<&[u8], Expr>, do_parse!(
77 | a: do_parse!(op: value!(SumOp::Add) >> t: mul >> ( ExprItem(op, t) )) >>
78 | b: many0!(do_parse!(op: op_sum_bin >> t: mul >> ( ExprItem(op, t) ))) >>
79 | ( {
80 | let mut list = b;
81 | list.insert(0, a);
82 | Expr { sum: list }
83 | } )
84 | ));
85 |
86 | named!(pub mul<&[u8], Term>, do_parse!(
87 | a: do_parse!(op: value!(MulOp::Mul) >> t: factor >> ( TermItem(op, t) )) >>
88 | b: many0!(do_parse!(op: op_mul_bin >> t: factor >> ( TermItem(op, t) ))) >>
89 | ( {
90 | let mut list = b;
91 | list.insert(0, a);
92 | Term { mul: list }
93 | } )
94 | ));
95 |
96 | #[derive(Debug)]
97 | enum RevFactor {
98 | Invocation(Vec),
99 | Index(DisjExpr),
100 | Attribute(String),
101 | }
102 |
103 | named!(factor<&[u8], Factor>, do_parse!(
104 | a: simple_factor >>
105 | b: many0!(attr_chain) >>
106 | ( {
107 | let res = b.into_iter().fold(a, |acc, rf| {
108 | trace!("::: acc, rf: {:?}, {:?}", acc, rf);
109 | match rf {
110 | RevFactor::Attribute(id) => Factor::Attribute(Attribute { id, on: box acc }),
111 | RevFactor::Index(expr) => Factor::Index(Index { index: box expr, on: box acc }),
112 | RevFactor::Invocation(args) => Factor::Invocation(Invocation { args, on: box acc }),
113 | }
114 | } );
115 | trace!("::: factor: {:?}", res);
116 | res
117 | })
118 | ));
119 |
120 | named!(attr_chain<&[u8], RevFactor>,
121 | do_parse!(
122 | many0!(multispace) >>
123 | rf: alt!(
124 | do_parse!(char!('.') >> many0!(multispace) >> id: identifier >>
125 | (RevFactor::Attribute(id))
126 | ) |
127 | do_parse!(char!('(') >> many0!(multispace) >> args: expr_list >> many0!(multispace) >> char!(')') >>
128 | (RevFactor::Invocation(args))
129 | ) |
130 | do_parse!(char!('[') >> index: expression >> char!(']') >>
131 | (RevFactor::Index(index))
132 | )
133 | ) >> ({
134 | trace!("::: RevFactor: {:?}", rf);
135 | rf
136 | })
137 | )
138 | );
139 |
140 | named!(simple_factor<&[u8], Factor>, alt!(literal | variable | subexpression) );
141 |
142 | named!(subexpression<&[u8], Factor>, do_parse!(
143 | char!('(') >> many0!(multispace) >> e: expression >> many0!(multispace) >> char!(')') >>
144 | (Factor::Subexpression(e))
145 | ));
146 |
147 | named!(variable<&[u8], Factor>, do_parse!(
148 | id: identifier >>
149 | inv: opt!(complete!(do_parse!(
150 | many0!(multispace) >> char!('(') >> many0!(multispace) >>
151 | e: expr_list >> many0!(multispace) >> char!(')') >>
152 | (e)
153 | ))) >>
154 | ({
155 | let var = Factor::Variable(id);
156 | let v = match inv {
157 | Some(args) => Invocation { on: Box::new(var), args } .into(),
158 | None => var
159 | };
160 | trace!("::: v: {:?}", v);
161 | v
162 | })
163 | ));
164 |
165 | named!(expr_list<&[u8], Vec >, do_parse!(
166 | lst: opt!(do_parse!(
167 | a: expression >>
168 | b: many0!(do_parse!(expr_sep >> e: expression >> (e) )) >>
169 | ({
170 | let mut lst = b;
171 | lst.insert(0, a);
172 | lst
173 | })
174 | )) >>
175 | ({
176 | trace!("::: expr_list: {:?}", lst);
177 | lst.unwrap_or_else(Vec::new)
178 | })
179 | ));
180 |
181 |
182 |
183 | named!(expr_sep<&[u8], ()>, do_parse!(
184 | many0!(multispace) >> char!(',') >> many0!(multispace) >>
185 | ()
186 | ));
187 |
188 |
189 | named!(op_disj_bin<&[u8], ()>, do_parse!(
190 | many0!(multispace) >> o: tag!("or") >> many0!(multispace) >>
191 | ({
192 | trace!(":::: or");
193 | match o {
194 | b"or" => (),
195 | _ => unreachable!()
196 | }
197 | })
198 | ));
199 |
200 | named!(op_conj_bin<&[u8], ()>, do_parse!(
201 | many0!(multispace) >> o: tag!("and") >> many0!(multispace) >>
202 | ({
203 | trace!(":::: and");
204 | match o {
205 | b"and" => (),
206 | _ => unreachable!()
207 | }
208 | })
209 | ));
210 |
211 | named!(op_cmp_bin<&[u8], CmpOp>, do_parse!(
212 | many0!(multispace) >>
213 | o: alt!(tag!("<=") | tag!("<") | tag!("==") | tag!("!=") | tag!("in") | tag!("not in") | tag!(">=") | tag!(">")) >>
214 | many0!(multispace) >>
215 | ({
216 | trace!(":::: cmp {:?}", o);
217 | match o {
218 | b"<" => CmpOp::Lt,
219 | b"<=" => CmpOp::Lte,
220 | b"==" => CmpOp::Eq,
221 | b"!=" => CmpOp::Neq,
222 | b"in" => CmpOp::In,
223 | b"not in" => CmpOp::Nin,
224 | b">=" => CmpOp::Gte,
225 | b">" => CmpOp::Gt,
226 | _ => unreachable!()
227 | }
228 | })
229 | ));
230 |
231 | named!(op_sum_bin<&[u8], SumOp>, do_parse!(
232 | many0!(multispace) >> o: alt!(tag!("+") | tag!("-")) >> many0!(multispace) >>
233 | ({
234 | match o {
235 | b"+" => SumOp::Add,
236 | b"-" => SumOp::Sub,
237 | _ => unreachable!()
238 | }
239 | })
240 | ));
241 |
242 | named!(op_mul_bin<&[u8], MulOp>, do_parse!(
243 | many0!(multispace) >> o: alt!(tag!("*") | tag!("/")) >> many0!(multispace) >>
244 | ({
245 | match o {
246 | b"*" => MulOp::Mul,
247 | b"/" => MulOp::Div,
248 | _ => unreachable!()
249 | }
250 | })
251 | ));
252 |
253 | // ---------------------------------------------------------------------------
254 |
255 | #[cfg(test)]
256 | mod tests {
257 | #![allow(clippy::used_underscore_binding)]
258 |
259 | use nom::IResult::Done;
260 |
261 | #[test]
262 | fn identifier() {
263 | assert_eq!(Done(&b""[..], "var_name".to_owned()), super::identifier(b"var_name"));
264 | assert_eq!(Done(&b""[..], "var_1".to_owned()), super::identifier(b"var_1"));
265 | assert!(super::identifier(b"_wrong").is_err());
266 | assert!(super::identifier(b"1wrong").is_err());
267 | }
268 |
269 | #[test]
270 | fn format() {
271 | use container::expression::FilterItem::Simple;
272 | assert_eq!(Done(&b""[..], Simple("e".into())), super::filter(b"|e"));
273 | assert_eq!(Done(&b""[..], Simple("e".into())), super::filter(b"| e"));
274 | assert_eq!(Done(&b""[..], Simple("e".into())), super::filter(b"| e"));
275 | assert!(super::filter(b"| 1wrong").is_err());
276 | assert!(super::filter(b"| _wrong").is_err());
277 | }
278 | }
279 |
280 |
281 |
282 |
283 |
284 |
285 |
286 |
287 |
288 |
289 |
290 |
291 |
292 | /*
293 | http://codinghighway.com/2015/05/25/down-with-redundant-parenthesis/
294 |
295 | expr -> term expr_r
296 |
297 | expr_r -> '+' term expr_r
298 | | '-' term expr_r
299 | | e
300 |
301 | term -> factor term_r
302 |
303 | term_r -> '*' factor term_r
304 | | '/' factor term_r
305 | | e
306 |
307 | factor -> number
308 | | '(' expr ')'
309 | */
310 |
311 | /*
312 |
313 | 5 + 6
314 |
315 | expr [5 + 6
316 | expr [term [5 + 6
317 | expr [term [factor [5 + 6
318 | expr [term [factor [number[5 + 6
319 | expr [term [factor [number[5] + 6
320 | expr [term [factor [number[5]] + 6
321 | expr [term [factor [number[5]] expr_r [ + 6
322 | expr [term [factor [number[5]] expr_r ['+' 6
323 | expr [term [factor [number[5]] expr_r ['+' term [6
324 | expr [term [factor [number[5]] expr_r ['+' term [factor [6
325 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6
326 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]
327 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]]
328 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [
329 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e
330 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]
331 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [
332 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [e
333 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [e]
334 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [e]]
335 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [e]]]
336 | expr [term [factor [number[5]] expr_r ['+' term [factor [number[6]] term_r [e]] expr_r [e]]]]
337 |
338 | expr
339 | term
340 | factor expr_r
341 | number '+' term expr_r
342 | 5 factor term_r e
343 | number e
344 | 6
345 |
346 |
347 | 5 '+' 6
348 |
349 |
350 | 5 + 6
351 |
352 | expr [
353 | term [
354 | factor [
355 | number[5]
356 | ]
357 | expr_r [
358 | '+'
359 | term [
360 | factor [
361 | number[6]
362 | ]
363 | term_r[e]
364 | ]
365 | expr_r[e]
366 | ]
367 | ]
368 | ]
369 |
370 |
371 | expr:
372 | term:
373 | factor:
374 | number:
375 | 5
376 | expr_r:
377 | '+'
378 | term:
379 | factor:
380 | number:
381 | 6
382 | term_r:
383 | e
384 | expr_r:
385 | e
386 | */
387 |
--------------------------------------------------------------------------------
/src/renderer/evaluator.rs:
--------------------------------------------------------------------------------
1 | use abc::{EvalResult, EvalError, InvokeError};
2 | use container::expression::*;
3 | use {Arg, VarContext};
4 |
5 |
6 | pub fn eval_expr<'r: 'c, 'c>(context: &'c VarContext<'r>, disj_expr: &DisjExpr) -> EvalResult> {
7 | let mut itr = disj_expr.list.iter();
8 | let conj = itr.next().unwrap();
9 | let mut acc = eval_conj(context, conj)?;
10 | for conj in itr {
11 | acc = match acc {
12 | // FIXME eval None as False?
13 | None => return Ok(None),
14 | Some(a) => match a.to_bool() {
15 | true => return Ok(Some(a)),
16 | false => eval_conj(context, conj)?,
17 | }
18 | }
19 | }
20 | Ok(acc)
21 | }
22 |
23 |
24 | pub fn eval_conj<'r: 'c, 'c>(context: &'c VarContext<'r>, conj_expr: &ConjExpr) -> EvalResult> {
25 | let mut itr = conj_expr.list.iter();
26 | let cmp = itr.next().unwrap();
27 | let mut acc = eval_cmp(context, cmp)?;
28 | for cmp in itr {
29 | acc = match acc {
30 | // FIXME eval None as False?
31 | None => return Ok(None),
32 | Some(acc) => match acc.to_bool() {
33 | true => eval_cmp(context, cmp)?,
34 | false => return Ok(Some(acc))
35 | }
36 | }
37 | }
38 | Ok(acc)
39 | }
40 |
41 |
42 | #[allow(unused_variables)]
43 | pub fn eval_cmp<'r: 'c, 'c>(context: &'c VarContext<'r>, cmp_expr: &CmpExpr) -> EvalResult> {
44 | let mut itr = cmp_expr.list.iter();
45 | let &CmpItem(_, ref expr) = itr.next().unwrap();
46 | let mut acc = eval_sum(context, expr)?;
47 | for &CmpItem(ref op, ref expr) in itr {
48 | acc = match acc {
49 | None => return Ok(None),
50 | Some(acc) => match eval_sum(context, expr)? {
51 | None => return Ok(None),
52 | Some(expr) => match *op {
53 | // todo error if is not partial_eq ?
54 | CmpOp::Eq => acc.try_as_partial_eq().map(|acc| acc.eq(&expr)),
55 | CmpOp::Neq => acc.try_as_partial_eq().map(|acc| acc.ne(&expr)),
56 | CmpOp::Lt => acc.try_as_partial_ord().and_then(|acc| acc.lt(&expr)),
57 | CmpOp::Gt => acc.try_as_partial_ord().and_then(|acc| acc.gt(&expr)),
58 | CmpOp::Lte => acc.try_as_partial_ord().and_then(|acc| acc.le(&expr)),
59 | CmpOp::Gte => acc.try_as_partial_ord().and_then(|acc| acc.ge(&expr)),
60 | CmpOp::In => unimplemented!(),
61 | CmpOp::Nin => unimplemented!(),
62 | }
63 | .map(Arg::from)
64 | }
65 | }
66 | }
67 | Ok(acc)
68 | }
69 |
70 |
71 | pub fn eval_sum<'r: 'c, 'c>(context: &'c VarContext<'r>, expr: &Expr) -> EvalResult> {
72 | let mut itr = expr.sum.iter();
73 | let &ExprItem(_, ref term) = itr.next().unwrap();
74 | let mut acc = eval_prod(context, term)?;
75 | for &ExprItem(ref op, ref term) in itr {
76 | acc = match acc {
77 | None => return Ok(None),
78 | Some(acc) => match eval_prod(context, term)? {
79 | None => return Ok(None),
80 | Some(term) => match *op {
81 | SumOp::Add => acc.try_add(term),
82 | SumOp::Sub => acc.try_sub(term),
83 | }
84 | }
85 | }
86 | }
87 | Ok(acc)
88 | }
89 |
90 |
91 | pub fn eval_prod<'r: 'c, 'c>(context: &'c VarContext<'r>, term: &Term) -> EvalResult> {
92 | let mut itr = term.mul.iter();
93 | let &TermItem(_, ref factor) = itr.next().unwrap();
94 | let mut acc = eval_factor(context, factor)?;
95 | for &TermItem(ref op, ref factor) in itr {
96 | acc = match acc {
97 | None => return Ok(None),
98 | Some(acc) => match eval_factor(context, factor)? {
99 | None => return Ok(None),
100 | Some(factor) => match *op {
101 | MulOp::Mul => acc.try_mul(factor),
102 | MulOp::Div => acc.try_div(factor),
103 | }
104 | }
105 | }
106 | }
107 | Ok(acc)
108 | }
109 |
110 |
111 | pub fn eval_factor<'r: 'c, 'c>(context: &'c VarContext<'r>, fctr: &Factor) -> EvalResult> {
112 | match *fctr {
113 | Factor::Variable(ref id) => Ok(context.get(id)),
114 | Factor::Literal(ref lit) => literal(lit),
115 | Factor::Subexpression(ref expr) => eval_expr(context, expr),
116 | Factor::Index(ref index) => eval_index(context, index),
117 | Factor::Attribute(ref attr) => eval_attribute(context, attr),
118 | Factor::Invocation(ref inv) => eval_invocation(context, inv),
119 | }
120 | }
121 |
122 |
123 | pub fn eval_index<'r: 'c, 'c>(context: &'c VarContext<'r>, index: &Index) -> EvalResult> {
124 | match eval_factor(context, &index.on)? {
125 | None => Err(EvalError::NotComposable),
126 | Some(value) => {
127 | if let Some(key) = eval_expr(context, &index.index)? {
128 | if let Some(key) = key.try_as_int() {
129 | return match value.try_as_indexable() {
130 | None => Err(EvalError::NotIndexable),
131 | // TODO consider negative values
132 | Some(indexable) => match indexable.get_index(key as usize) {
133 | None => Err(EvalError::IndexNotExists(key as usize)),
134 | // fixme extra clone
135 | Some(result) => Ok(Some(result.to_owned())),
136 | }
137 | }
138 | }
139 |
140 | if let Some(key) = key.try_as_string() {
141 | return match value.try_as_mappable() {
142 | None => Err(EvalError::NotMappable),
143 | Some(mappable) => match mappable.get_by_key(key.as_ref()) {
144 | None => Err(EvalError::KeyNotExists(key.into_owned().into())),
145 | // fixme extra clone
146 | Some(result) => Ok(Some(result.to_owned())),
147 | }
148 | }
149 | }
150 | }
151 | Err(EvalError::UnexpectedIndexType)
152 | }
153 | }
154 | }
155 |
156 |
157 | pub fn eval_attribute<'r: 'c, 'c>(context: &'c VarContext<'r>, attr: &Attribute) -> EvalResult> {
158 | // eval_factor(context, &attr.on)
159 | match eval_factor(context, &attr.on)? {
160 | None => Err(EvalError::NotComposable),
161 | Some(value) => {
162 | // Ok(Some(value))
163 | match value.try_as_composable() {
164 | None => Err(EvalError::NotComposable),
165 | Some(composable) => {
166 | match composable.get_attr(&attr.id) {
167 | None => Err(EvalError::AttributeNotExists(attr.id.clone().into())),
168 | // fixme extra clone
169 | Some(result) => Ok(Some(result.to_owned())),
170 | }
171 | }
172 | }
173 | }
174 | }
175 | }
176 |
177 |
178 | pub fn eval_invocation<'r: 'c, 'c>(context: &'c VarContext<'r>, inv: &Invocation) -> EvalResult> {
179 | match eval_factor(context, &inv.on)? {
180 | None => Err(InvokeError::NotInvokable)?,
181 | Some(value) => match value.try_as_invokable() {
182 | None => Err(InvokeError::NotInvokable)?,
183 | Some(invokable) => {
184 | let mut args: Vec = Vec::with_capacity(inv.args.len());
185 | for expr in &inv.args {
186 | match eval_expr(context, expr)? {
187 | None => Err(EvalError::NoneArg)?,
188 | Some(val) => args.push(val)
189 | }
190 | }
191 | invokable.invoke(args.as_slice(), context)
192 | }
193 | }
194 | }
195 | }
196 |
197 |
198 | pub fn literal(l: &Literal) -> EvalResult> {
199 | Ok(Some(match *l {
200 | Literal::Str(ref string) => Arg::from(string.clone()),
201 | Literal::Char(ref chr) => Arg::from(*chr),
202 | Literal::Int(ref int) => Arg::from(*int),
203 | Literal::Real(ref real) => Arg::from(*real),
204 | }))
205 | }
206 |
207 |
208 | #[cfg(test)]
209 | mod tests {
210 | #![allow(clippy::used_underscore_binding)]
211 | use nom::IResult;
212 | use std::fmt::Debug;
213 |
214 | use abc::*;
215 | use {Incrust, Arg, Args, VarContext, ex, Template};
216 | use parser::expressions::expression as parse_expr;
217 | use super::eval_expr;
218 |
219 |
220 | fn unwrap_iresult(result: IResult) -> T {
221 | match result {
222 | IResult::Done(_, v) => v,
223 | IResult::Error(e) => panic!("{:?}", e),
224 | IResult::Incomplete(i) => panic!("{:?}", i),
225 | }
226 | }
227 |
228 | fn test_eval_expr(context: &VarContext, a: &str, b: &[u8]) {
229 | let b = unwrap_iresult(parse_expr(b));
230 | let r = eval_expr(&context, &b);
231 | let res = r.unwrap().unwrap()
232 | .try_as_string()
233 | .map(|c| c.into_owned())
234 | .unwrap();
235 | assert_eq!(a, res)
236 | }
237 |
238 |
239 | #[test]
240 | fn eval_attr() {
241 | let args: Args = hashmap!{ "the_one".into() => ex("World") };
242 | let incrust = Incrust::default();
243 | let template = Template::default();
244 | let context = incrust.create_global_context(&template, &args).unwrap();
245 | let context = context.top_scope();
246 |
247 | test_eval_expr(&context, "1", br#""a".length"#);
248 | test_eval_expr(&context, "2", br#"("a" + "b").length"#);
249 | test_eval_expr(&context, "5", br#"the_one . length"#);
250 | }
251 |
252 | #[test]
253 | fn eval_factor() {
254 | use container::expression::{Factor, Literal};
255 | use super::eval_factor;
256 |
257 | let int_one: Factor = Literal::Int(1_i64).into();
258 | let the_one = Factor::Variable("the_one".into());
259 |
260 | let args: Args = hashmap!{ "the_one".into() => ex("World") };
261 | let incrust = Incrust::default();
262 | let template = Template::default();
263 | let context = incrust.create_global_context(&template, &args).unwrap();
264 | let context = context.top_scope();
265 |
266 | let x = |r: EvalResult| {
267 | r.unwrap().unwrap()
268 | .try_as_string()
269 | .map(|c| c.into_owned())
270 | .unwrap()
271 | };
272 |
273 | assert!("1" == x(eval_factor(&context, &int_one)));
274 | assert!("World" == x(eval_factor(&context, &the_one)));
275 | assert!("Space" != x(eval_factor(&context, &the_one)));
276 |
277 | test_eval_expr(&context, "1", b"1");
278 | test_eval_expr(&context, "2", b"1 + 1");
279 | test_eval_expr(&context, "0", b"1 - 1");
280 | test_eval_expr(&context, "1", b"2 / 2");
281 | test_eval_expr(&context, "1", b"3 / 2.0");
282 | test_eval_expr(&context, "1.5", b"3.0 / 2");
283 |
284 | test_eval_expr(&context, "ab", br#""a" + "b""#);
285 | test_eval_expr(&context, "ab", br#"("a" + "b")"#);
286 | }
287 |
288 | #[test]
289 | fn eval_bool() {
290 | let args: Args = hashmap!{ "the_one".into() => ex("World") };
291 | let incrust = Incrust::default();
292 | let template = Template::default();
293 | let context = incrust.create_global_context(&template, &args).unwrap();
294 | let context = context.top_scope();
295 |
296 | test_eval_expr(&context, "1", b"0 or 1");
297 | test_eval_expr(&context, "0", b"0 and 1");
298 | test_eval_expr(&context, "str", br#""" or "str""#);
299 | test_eval_expr(&context, "", br#""" and "str""#);
300 | test_eval_expr(&context, "2", br#"0 and 1 or 2"#);
301 | test_eval_expr(&context, "2", br#"0 or 1 and 2"#);
302 | test_eval_expr(&context, "1", br#"0 or 1 or 2"#);
303 | test_eval_expr(&context, "1", br#"1 or 0 and 2"#);
304 | }
305 |
306 | #[test]
307 | fn compare() {
308 | let args: Args = hashmap!{ "the_one".into() => ex("World") };
309 | let incrust = Incrust::default();
310 | let template = Template::default();
311 | let context = incrust.create_global_context(&template, &args).unwrap();
312 | let context = context.top_scope();
313 |
314 | test_eval_expr(&context, "true", b"1 == 1");
315 | test_eval_expr(&context, "true", b"1 != 2");
316 | test_eval_expr(&context, "false", b"1 == 2");
317 |
318 | test_eval_expr(&context, "true", br#""1" == "1""#);
319 | test_eval_expr(&context, "true", br#""1" != "2""#);
320 | test_eval_expr(&context, "false", br#""1" == "2""#);
321 |
322 | test_eval_expr(&context, "false", br#""1" == 1"#);
323 | test_eval_expr(&context, "true", br#""1" != 1"#);
324 |
325 | test_eval_expr(&context, "false", br#"1 == "1""#);
326 | test_eval_expr(&context, "true", br#"1 != "1""#);
327 |
328 | test_eval_expr(&context, "true", b"1 <= 1");
329 | test_eval_expr(&context, "false", b"1 < 1");
330 | test_eval_expr(&context, "true", b"1 <= 2");
331 | test_eval_expr(&context, "true", b"1 < 2");
332 | test_eval_expr(&context, "false", b"1 >= 2");
333 | test_eval_expr(&context, "false", b"1 > 2");
334 |
335 | test_eval_expr(&context, "true", b"1 >= 1");
336 | test_eval_expr(&context, "false", b"1 > 1");
337 | test_eval_expr(&context, "true", b"1 >= 1");
338 | test_eval_expr(&context, "true", b"2 > 1");
339 | test_eval_expr(&context, "false", b"2 <= 1");
340 | test_eval_expr(&context, "false", b"2 < 1");
341 | }
342 |
343 | // #[test]
344 | // fn eval_expr() {
345 | // let int_one: Factor = Literal::Int(1isize).into();
346 | //
347 | // let args: Args = hashmap!{ "two" => ex(2isize) };
348 | // let context = Context::new(&Default::default(), &args);
349 | //
350 | // let x = |r: EvalResult| r.unwrap().unwrap().to_istring().unwrap();
351 | //
352 | // assert!("1" == x(super::eval_factor(&int_one, &context)));
353 | // assert!("World" == x(super::eval_factor(&the_one, &context)));
354 | // assert!("Space" != x(super::eval_factor(&the_one, &context)));
355 | // }
356 | }
357 |
--------------------------------------------------------------------------------