WIP new API. InvokeError. Box<Iterator>. Version bump 0.2.12

Author: alexander-irbis

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "incrust"
-version = "0.2.11"
+version = "0.2.12"
 authors = ["Alexander Irbis <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "Template engine inspired by Jinja2"

README.md

@@ -22,7 +22,7 @@ Incrust is [available on crates.io](https://crates.io/crates/incrust) and can be
 
 ```toml
 [dependencies]
-incrust = "=0.2.11"
+incrust = "=0.2.12"
 ```
 
 For ease of use hashmaps you may use the [maplit](https://crates.io/crates/maplit)

src/renderer/abc.rs

@@ -8,7 +8,7 @@ pub type EvalResult<T> = Result<Option<T>, EvalError>;
 
 #[derive(Debug)]
 pub enum EvalError {
-    NotInvocable,
+    Invoke(InvokeError),
     NoneArg,
     NotComposable,
     AttributeNotExists(String),
@@ -17,6 +17,24 @@ pub enum EvalError {
 }
 
 
+#[derive(Debug)]
+pub enum InvokeError {
+    NotInvocable,
+    WrongArgsNumber(usize, usize),
+    WrongArgType(usize, ExpectedArgType),
+}
+
+#[derive(Debug)]
+pub enum ExpectedArgType {
+    String,
+    Int,
+    Real,
+    Bool
+}
+
+impl From<InvokeError> for EvalError { fn from(err: InvokeError)  -> Self { EvalError::Invoke(err) } }
+
+
 pub type FilterResult<T> = Result<Option<T>, FilterError>;
 
 #[derive(Debug)]

src/renderer/evaluator.rs

@@ -1,4 +1,4 @@
-use abc::{EvalResult, EvalError};
+use abc::{EvalResult, EvalError, InvokeError};
 use container::expression::*;
 use {Arg, Context};
 
@@ -132,14 +132,14 @@ pub fn eval_attribute<'r>(context: &'r Context<'r>, attr: &'r Attribute) -> Eval
 
 pub fn eval_invocation<'r>(context: &'r Context<'r>, inv: &'r Invocation) -> EvalResult<Arg<'r>> {
     match eval_factor(context, &inv.on)? {
-        None => Err(EvalError::NotInvocable),
+        None => Err(InvokeError::NotInvocable)?,
         Some(value) => match value.try_as_invocable() {
-            None => Err(EvalError::NotInvocable),
+            None => Err(InvokeError::NotInvocable)?,
             Some(invocable) => {
                 let mut args: Vec<Arg> = Vec::with_capacity(inv.args.len());
                 for expr in &inv.args {
                     match eval_expr(context, expr)? {
-                        None => return Err(EvalError::NoneArg),
+                        None => Err(EvalError::NoneArg)?,
                         Some(val) => args.push(val)
                     }
                 }

src/types/abc.rs

@@ -91,33 +91,34 @@ pub trait IArithm {
     fn try_div<'o>(&self, other: Arg<'o>) -> Option<Arg<'o>>;
 }
 
-pub trait IInvocable: Send + Sync {
+pub trait IInvocable {
     fn invoke<'r: 'rr, 'rr>(&self, args: &'rr [Arg<'r>], context: &'r Context<'r>) -> EvalResult<Arg<'r>>;
 }
 
-pub trait IIterable: Send + Sync {
+pub trait IIterable {
     fn is_empty(&self) -> bool;
-    fn ivalues(&self) -> VIterator;
+    fn ivalues<'s: 'i, 'i>(&'s self) -> Box<Iterator<Item=Arg> + 'i>;
 }
 
-pub trait IIndexable: Send + Sync {
+pub trait IIndexable {
 //    fn has_index(&self, index: usize) -> bool;
-    fn get_index(&self, index: usize) -> Option<&Arg>;
-//    fn as_slice(&self, range: Range) -> &[BType];
+    fn get_index(&self, index: usize) -> Option<Arg>;
+    fn is_empty(&self) -> bool;
     fn len(&self) -> usize;
+    // fn as_slice(&self) -> &[Arg];
 }
 
-pub trait IComposable: Send + Sync {
+pub trait IComposable {
     fn get_attr(&self, id: &str) -> Option<Arg>;
 //    fn attrs(&self) -> &[BType];
 }
 
-pub trait IPartialEq: Send + Sync {
+pub trait IPartialEq {
     fn eq<'o>(&self, other: &'o Arg<'o>) -> bool;
     fn ne<'o>(&self, other: &'o Arg<'o>) -> bool { !self.eq(other) }
 }
 
-pub trait IPartialOrd: Send + Sync {
+pub trait IPartialOrd {
     fn partial_cmp<'o>(&self, other: &'o Arg<'o>) -> Option<Ordering>;
     fn lt<'o>(&self, other: &'o Arg<'o>) -> Option<bool> {
         self.partial_cmp(other).map(|res| res == Ordering::Less)

src/types/list.rs

@@ -42,28 +42,29 @@ impl <'r> AsComposable for Vec<Arg<'r>> {
 }
 
 
-// --------------------------------------------------------------------------------------------------------------------
-
-
 impl <'r> IIterable for Vec<Arg<'r>> {
     fn is_empty(&self) -> bool {
         Vec::is_empty(self)
     }
 
-    fn ivalues(&self) -> VIterator {
-        VIterator { me: self.iter() }
+    fn ivalues<'s: 'i, 'i>(&'s self) -> Box<Iterator<Item=Arg> + 'i> {
+        box self.iter().map(Arg::to_ref)
     }
 }
 
 
 impl <'r> IIndexable for Vec<Arg<'r>> {
-    fn get_index(&self, index: usize) -> Option<&Arg> {
-        self.get(index)
+    fn get_index(&self, index: usize) -> Option<Arg> {
+        self.get(index).map(Arg::to_ref)
     }
 
     fn len(&self) -> usize {
         Vec::len(self)
     }
+
+    fn is_empty(&self) -> bool {
+        Vec::is_empty(self)
+    }
 }
 
 
@@ -106,3 +107,82 @@ impl <'r> IComposable for Vec<Arg<'r>> {
 //        }
 //    }
 //}
+
+
+// --------------------------------------------------------------------------------------------------------------------
+
+
+impl <'r, 't> Type<'t> for &'r [Arg<'r>] {
+    //    fn clone_type(&self) -> Arg<'static> {
+    //        Arg::Owned(box self.clone())
+    //    }
+    fn clone_type(&self) -> Arg<'static> {
+        Arg::Owned(
+            box self.into_iter()
+                .map(|v| (*v).clone_type())
+                .collect::<Vec<Arg<'static>>>()
+        )
+    }
+}
+
+// todo resolve specialization conflict
+//impl IRender for Vec<BType> {
+//    default fn render<'w>(&self, writer: &mut Writer<'w>) -> fmt::Result {
+//        debug!("Default render for List {:?}", self);
+//        write!(writer, "#List")
+//    }
+//}
+
+impl <'r> AsBool for &'r [Arg<'r>] {
+    fn to_bool(&self) -> bool {
+        !(*self).is_empty()
+    }
+}
+
+impl <'r> AsIterable for &'r [Arg<'r>] {
+    fn try_as_iterable(&self) -> Option<&IIterable> {
+        Some(self)
+    }
+}
+
+impl <'r> AsComposable for &'r [Arg<'r>] {
+    fn try_as_composable(&self) -> Option<&IComposable> {
+        Some(self)
+    }
+}
+
+
+impl <'r> IIterable for &'r [Arg<'r>] {
+    fn is_empty(&self) -> bool {
+        (*self).is_empty()
+    }
+
+    fn ivalues<'s: 'i, 'i>(&'s self) -> Box<Iterator<Item=Arg> + 'i> {
+        box self.iter().map(Arg::to_ref)
+    }
+}
+
+
+impl <'r> IIndexable for &'r [Arg<'r>] {
+    fn get_index(&self, index: usize) -> Option<Arg> {
+        self.get(index).map(Arg::to_ref)
+    }
+
+    fn len(&self) -> usize {
+        (*self).len()
+    }
+
+    fn is_empty(&self) -> bool {
+        (*self).is_empty()
+    }
+}
+
+
+impl <'r> IComposable for &'r [Arg<'r>] {
+    fn get_attr(&self, id: &str) -> Option<Arg> {
+        match id {
+            "length" => Some(ex(self.len() as i64)),
+            _ => None
+        }
+    }
+}