Move TemplateInput and related code into separate module

1 files changed, 3 insertions, 104 deletions

diff --git a/askama_shared/src/lib.rs b/askama_shared/src/lib.rs
index f38a6df..57e4aff 100644
--- a/askama_shared/src/lib.rs
+++ b/askama_shared/src/lib.rs
@@ -17,10 +17,10 @@ pub mod path;
 
 mod escaping;
 mod generator;
+mod input;
 mod parser;
 
-use std::borrow::Cow;
-use std::path::PathBuf;
+use input::Print;
 
 
 /// Takes a `syn::DeriveInput` and generates source code for it
@@ -31,7 +31,7 @@ use std::path::PathBuf;
 /// the parse tree and/or generated source according to the `print` key's
 /// value as passed to the `template()` attribute.
 pub fn build_template(ast: &syn::DeriveInput) -> String {
-    let data = TemplateInput::new(ast);
+    let data = input::TemplateInput::new(ast);
     let nodes = parser::parse(data.source.as_ref());
     if data.meta.print == Print::Ast || data.meta.print == Print::All {
         println!("{:?}", nodes);
@@ -43,28 +43,6 @@ pub fn build_template(ast: &syn::DeriveInput) -> String {
     code
 }
 
-struct TemplateInput<'a> {
-    pub ast: &'a syn::DeriveInput,
-    pub meta: TemplateMeta<'a>,
-    pub path: PathBuf,
-    pub source: Cow<'a, str>,
-}
-
-impl<'a> TemplateInput<'a> {
-    fn new(ast: &'a syn::DeriveInput) -> TemplateInput<'a> {
-        let meta = TemplateMeta::new(ast);
-        let (path, source) = match meta.source {
-            Source::Source(s) => (PathBuf::new(), Cow::Borrowed(s)),
-            Source::Path(s) => {
-                let path = path::find_template_from_path(&s, None);
-                let src = path::get_template_source(&path);
-                (path, Cow::Owned(src))
-            },
-        };
-        TemplateInput { ast, meta, path, source }
-    }
-}
-
 mod errors {
     error_chain! {
         foreign_links {
@@ -73,82 +51,3 @@ mod errors {
         }
     }
 }
-
-// Holds metadata for the template, based on the `template()` attribute.
-struct TemplateMeta<'a> {
-    source: Source<'a>,
-    print: Print,
-}
-
-impl<'a> TemplateMeta<'a> {
-    fn new(ast: &'a syn::DeriveInput) -> TemplateMeta<'a> {
-        let attr = ast.attrs.iter().find(|a| a.name() == "template");
-        if attr.is_none() {
-            let msg = format!("'template' attribute not found on struct '{}'",
-                              ast.ident.as_ref());
-            panic!(msg);
-        }
-
-        let attr = attr.unwrap();
-        let mut source = None;
-        let mut print = Print::None;
-        if let syn::MetaItem::List(_, ref inner) = attr.value {
-            for nm_item in inner {
-                if let syn::NestedMetaItem::MetaItem(ref item) = *nm_item {
-                    if let syn::MetaItem::NameValue(ref key, ref val) = *item {
-                        match key.as_ref() {
-                            "path" => if let syn::Lit::Str(ref s, _) = *val {
-                                source = Some(Source::Path(s.as_ref()));
-                            } else {
-                                panic!("template path must be string literal");
-                            },
-                            "source" => if let syn::Lit::Str(ref s, _) = *val {
-                                source = Some(Source::Source(s.as_ref()));
-                            } else {
-                                panic!("template source must be string literal");
-                            },
-                            "print" => if let syn::Lit::Str(ref s, _) = *val {
-                                print = s.into();
-                            } else {
-                                panic!("print value must be string literal");
-                            },
-                            _ => { panic!("unsupported annotation key found") }
-                        }
-                    }
-                }
-            }
-        }
-
-        match source {
-            Some(s) => TemplateMeta { source: s, print },
-            None => panic!("template path or source not found in struct attributes"),
-        }
-    }
-}
-
-
-enum Source<'a> {
-    Path(&'a str),
-    Source(&'a str),
-}
-
-#[derive(PartialEq)]
-enum Print {
-    All,
-    Ast,
-    Code,
-    None,
-}
-
-impl<'a> From<&'a String> for Print {
-    fn from(s: &'a String) -> Print {
-        use Print::*;
-        match s.as_ref() {
-            "all" => All,
-            "ast" => Ast,
-            "code" => Code,
-            "none" => None,
-            v => panic!("invalid value for print option: {}", v),
-        }
-    }
-}