Renamed to DeepCrow

8 files changed, 82 insertions, 82 deletions

diff --git a/crimtag/Cargo.lock b/deepcrow/Cargo.lock
index f7e6686..9bfb874 100644
--- a/crimtag/Cargo.lock
+++ b/deepcrow/Cargo.lock
@@ -3,5 +3,5 @@
 version = 4
 
 [[package]]
-name = "crimtag"
+name = "deepcrow"
 version = "0.1.0"
diff --git a/crimtag/Cargo.toml b/deepcrow/Cargo.toml
index e48d065..de3156a 100644
--- a/crimtag/Cargo.toml
+++ b/deepcrow/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "crimtag"
+name = "deepcrow"
 version = "0.1.0"
 edition = "2024"
 
diff --git a/crimtag/src/context.rs b/deepcrow/src/context.rs
index a922fd8..4a22cdd 100644
--- a/crimtag/src/context.rs
+++ b/deepcrow/src/context.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::fmt;
 
-use crate::error::CrimResult;
+use crate::error::Result;
 
 use crate::{Identifier,IdentifierValue};
 
@@ -19,7 +19,7 @@ impl<'a> MappedStructure<'a> for Context {
 
 pub trait MappedList<'a> {
     fn get_index(&'a self, id: usize) -> Option<MappedValue<'a>>;
-    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> CrimResult<()>) -> CrimResult<String>;
+    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> Result<()>) -> Result<String>;
 }
     
 impl<'a, T: MappedStructure<'a>> MappedList<'a> for Vec<T> {
@@ -31,7 +31,7 @@ impl<'a, T: MappedStructure<'a>> MappedList<'a> for Vec<T> {
         }
     }
 
-    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> CrimResult<()>) -> CrimResult<String> {
+    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> Result<()>) -> Result<String> {
         let mut buf = String::new();
         for i in self {
             func( &MappedValue::Struct(i), &mut buf )?;
@@ -49,7 +49,7 @@ impl<'a> MappedList<'a> for Vec<Value> {
         }
     }
 
-    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> CrimResult<()>) -> CrimResult<String> {
+    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> Result<()>) -> Result<String> {
         let mut buf = String::new();
         for i in self {
             func( &Into::<MappedValue<'a>>::into( i ), &mut buf )?;
@@ -67,7 +67,7 @@ impl<'a> MappedList<'a> for Vec<MappedValue<'a>> {
         }
     }
 
-    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> CrimResult<()>) -> CrimResult<String> {
+    fn for_each(&'a self, func: &dyn Fn(&MappedValue<'a>, &mut String) -> Result<()>) -> Result<String> {
         let mut buf = String::new();
         for i in self {
             func( i, &mut buf )?;
diff --git a/crimtag/src/error.rs b/deepcrow/src/error.rs
index bbb5d6f..8fe21f0 100644
--- a/crimtag/src/error.rs
+++ b/deepcrow/src/error.rs
@@ -5,12 +5,12 @@ use std::fmt;
 use crate::position::*;
 
 #[derive(Debug)]
-pub struct CrimError {
+pub struct DeepCrowError {
     position: Position,
     what: String,
 }
 
-impl CrimError {
+impl DeepCrowError {
     pub fn parse( position: Position, what: String ) -> Self {
         Self {
             position,
@@ -48,12 +48,12 @@ impl CrimError {
     }
 }
 
-impl fmt::Display for CrimError {
+impl fmt::Display for DeepCrowError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Error parsing input: {}", "yeah")
     }
 }
 
-impl Error for CrimError { }
+impl Error for DeepCrowError { }
 
-pub type CrimResult<T> = Result<T, CrimError>;
+pub type Result<T> = std::result::Result<T, DeepCrowError>;
diff --git a/crimtag/src/lexer.rs b/deepcrow/src/lexer.rs
index d4d39e9..d4d39e9 100644
--- a/crimtag/src/lexer.rs
+++ b/deepcrow/src/lexer.rs
diff --git a/crimtag/src/lib.rs b/deepcrow/src/lib.rs
index 0fe0e4e..b10cd03 100644
--- a/crimtag/src/lib.rs
+++ b/deepcrow/src/lib.rs
@@ -9,14 +9,14 @@ mod position;
 mod error;
 pub mod context;
 
-pub use derive::CrimtagMappable;
+pub use derive::DeepCrowMappable;
 
-pub use error::{CrimError,CrimResult};
+pub use error::{DeepCrowError,Result};
 pub use position::*;
 pub use context::{Context,Value,MappedStructure,StatefulContext,MappedValue,MappedList,MappedHash};
 
 #[derive(Debug)]
-pub struct Crimtag {
+pub struct DeepCrow {
     views: HashMap<String, View>,
     sources: Vec<ViewSource>,
 }
@@ -43,7 +43,7 @@ struct View {
 }
 
 impl View {
-    fn process(&self, input: &dyn for<'a> MappedStructure<'a>) -> CrimResult<Context> {
+    fn process(&self, input: &dyn for<'a> MappedStructure<'a>) -> Result<Context> {
         let mut out_vars = Context::new();
         for output in &self.outputs {
             let mut buf = String::new();
@@ -80,7 +80,7 @@ pub enum IdentifierValue {
 
 pub type Identifier = Vec<IdentifierValue>;
 
-impl Crimtag {
+impl DeepCrow {
     pub fn new() -> Self {
         Self {
             views: HashMap::new(),
@@ -101,7 +101,7 @@ impl Crimtag {
         idx
     }
 
-    pub fn load_file(&mut self, path: &Path) -> Result<(),Box::<dyn Error>> {
+    pub fn load_file(&mut self, path: &Path) -> std::result::Result<(),Box::<dyn Error>> {
         let time = if let Ok(meta) = path.metadata() {
             if let Ok(t) = meta.modified() {
                 t
@@ -129,13 +129,13 @@ impl Crimtag {
         Ok(())
     }
 
-    pub fn load_static(&mut self, data: &str) -> CrimResult<()> {
+    pub fn load_static(&mut self, data: &str) -> Result<()> {
         let source_id = self.id_source( &ViewSource::Static );
         let p = parser::Parser::new();
         self.register_views( p.parse( &data, source_id )? )
     }
 
-    pub fn load_external(&mut self, key: &str, data: &str) -> CrimResult<()> {
+    pub fn load_external(&mut self, key: &str, data: &str) -> Result<()> {
         let source_id = self.id_source(
             &ViewSource::External{ key: key.to_string()}
             );
@@ -146,7 +146,7 @@ impl Crimtag {
             )
     }
 
-    fn register_views(&mut self, views: Vec<View>) -> CrimResult<()> {
+    fn register_views(&mut self, views: Vec<View>) -> Result<()> {
         for view in views {
             self.views.insert( view.name.clone(), view );
         }
@@ -165,15 +165,15 @@ impl Crimtag {
         }
     }
 
-    pub fn render_partial(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> CrimResult<Context> {
+    pub fn render_partial(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> Result<Context> {
         if let Some(view) = self.views.get(view) {
             return view.process( input )
         } else {
-            return Err(CrimError::other("No such view found".into()));
+            return Err(DeepCrowError::other("No such view found".into()));
         }
     }
 
-    pub fn render(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> CrimResult<String> {
+    pub fn render(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> Result<String> {
         if let Some(view) = self.views.get( view ) {
             //println!("::Token tree::\n{:?}", view );
             let mut output = view.process( input )?;
@@ -185,17 +185,17 @@ impl Crimtag {
 
                     Ok(s)
                 } else {
-                    Err(CrimError::other("No content found in root layout.".into()))
+                    Err(DeepCrowError::other("No content found in root layout.".into()))
                 }
             }
 
         } else {
-            Err(CrimError::other("No such view found".into()))
+            Err(DeepCrowError::other("No such view found".into()))
         }
     }
 }
 
-fn exec<'a>(input: &StatefulContext<'a>, tokens: &Vec<Token>, buf: &mut String) -> CrimResult<()> {
+fn exec<'a>(input: &StatefulContext<'a>, tokens: &Vec<Token>, buf: &mut String) -> Result<()> {
     for token in tokens {
         match token {
             Token::Loop(ident,code) => {
@@ -320,7 +320,7 @@ mod tests {
 
     #[test]
     fn parsing() {
-        let mut ct = Crimtag::new();
+        let mut ct = DeepCrow::new();
         if let Err(e) = ct.load_static(r#"Here is a sample
 [|view "index" theme="standard"|><html><body>Hi</body></html><|view|]
 That was fun! now a placeholder: [|view "placeholder"|] and now one with an implicit [|view "simple"|>Body -> [|show content|] <- and end<|view|] aoeu
@@ -360,8 +360,8 @@ Now with explicit outputs:
     }
 
     #[test]
-    fn loops() -> Result<(),CrimError> {
-        let mut ct = Crimtag::new();
+    fn loops() -> Result<()> {
+        let mut ct = DeepCrow::new();
         ct.load_static(r#"Looping code:
 [|view "index"|>We will enumerate people here:[|loop people|>
  - [|show last_name|], [|show first_name|][|if show_title |>: [|show title|] <|else|> **title redacted** <|if|] ::>[|loop tags|> [|show tag|]<|loop|] <:: <|loop|]
@@ -419,8 +419,8 @@ Now with explicit outputs:
     }
 
     #[test]
-    fn conditional() -> Result<(),CrimError> {
-        let mut ct = Crimtag::new();
+    fn conditional() -> Result<()> {
+        let mut ct = DeepCrow::new();
         ct.load_static(r#"Hi there
 [|view "index"|>
     Color: [|if is_red|> red <|elif is_blue |> blue <|else|> green <|if|]
@@ -525,7 +525,7 @@ Now with explicit outputs:
     }
     
     #[test]
-    fn custom() -> Result<(), CrimError> {
+    fn custom() -> Result<()> {
         let page = Page::new();
 
         println!("{:?}",
diff --git a/crimtag/src/parser.rs b/deepcrow/src/parser.rs
index 4f7ff6a..fbfc44e 100644
--- a/crimtag/src/parser.rs
+++ b/deepcrow/src/parser.rs
@@ -36,9 +36,9 @@ impl<'a> Context<'a> {
     }
 
     /*
-    pub fn check_unwrapped<T: Fn( &SymbolType, &SymbolType ) -> bool>(&self, context: &str, f: T) -> CrimResult<bool> {
+    pub fn check_unwrapped<T: Fn( &SymbolType, &SymbolType ) -> bool>(&self, context: &str, f: T) -> Result<bool> {
         if self.cur().is_none() || self.peek().is_none() {
-            Err(CrimError::eos( context ))
+            Err(DeepCrowError::eos( context ))
         } else  {
             Ok(f( self.cur().unwrap().symbol(), self.peek().unwrap().symbol()))
         }
@@ -51,21 +51,21 @@ impl<'a> Context<'a> {
 }
 
 trait SymbolHelper {
-    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> CrimResult<bool>;
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> Result<bool>;
     #[allow(dead_code)]
-    fn is_valid_tag_name(&self) -> CrimResult<bool>;
+    fn is_valid_tag_name(&self) -> Result<bool>;
 }
 
 impl<'a> SymbolHelper for Option<Symbol<'a>> {
-    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> CrimResult<bool> {
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> Result<bool> {
         if let Some(st) = self {
             Ok(f( &st.symbol() ))
         } else {
-            Err(CrimError::eos( context ))
+            Err(DeepCrowError::eos( context ))
         }
     }
     
-    fn is_valid_tag_name(&self) -> CrimResult<bool> {
+    fn is_valid_tag_name(&self) -> Result<bool> {
         if let Some(st) = self {
             Ok(match st.symbol() {
                 SymbolType::Token(_) |
@@ -79,7 +79,7 @@ impl<'a> SymbolHelper for Option<Symbol<'a>> {
                 _ => false
             })
         } else {
-            Err(CrimError::parse(
+            Err(DeepCrowError::parse(
                 Position::none(),
                 "Unexpeceted end of stream.".to_string()
                 ))
@@ -183,17 +183,17 @@ impl Parser {
         }
     }
 
-    fn lex_error<T>(&self, error: &Symbol) -> CrimResult<T> {
+    fn lex_error<T>(&self, error: &Symbol) -> Result<T> {
         if let SymbolType::Error{what} = error.symbol() {
-            Err(CrimError::parse( *error.start(),
+            Err(DeepCrowError::parse( *error.start(),
                 format!("What: {:?}", *what)
             ))
         } else {
-            Err(CrimError::parse( Position::none(), "Not an error?".into()))
+            Err(DeepCrowError::parse( Position::none(), "Not an error?".into()))
         }
     }
 
-    pub fn parse(&self, src: &str, source: usize ) -> CrimResult<Vec<View>> {
+    pub fn parse(&self, src: &str, source: usize ) -> Result<Vec<View>> {
         let ll = Lexer::new( src );
         let mut ctx = Context::new( ll, source );
 
@@ -201,7 +201,7 @@ impl Parser {
         self.p_input( &mut ctx )
     }
 
-    fn p_input(&self, ctx: &mut Context ) -> CrimResult<Vec<View>> {
+    fn p_input(&self, ctx: &mut Context ) -> Result<Vec<View>> {
         let mut tags = Vec::new();
         loop {
             if ctx.cur().is_none() {
@@ -218,7 +218,7 @@ impl Parser {
                     self.lex_error( &ctx.cur().unwrap() )?;
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         format!("Unexpected symbol {:?} found looking for tags.", ctx.cur().unwrap().symbol() )
                     ));
@@ -235,7 +235,7 @@ impl Parser {
                 let BuildResult::View(view) = tag.build( ctx )? {
                     views.push( view );
             } else {
-                return Err(CrimError::parse(
+                return Err(DeepCrowError::parse(
                     start_pos,
                     format!("Expected view at root, found {:?}", name )
                     ));
@@ -244,7 +244,7 @@ impl Parser {
         Ok(views)
     }
 
-    fn parse_tag<'a>(&self, ctx: &mut Context<'a>) -> CrimResult<TagBuilder<'a>> {
+    fn parse_tag<'a>(&self, ctx: &mut Context<'a>) -> Result<TagBuilder<'a>> {
         let start_sym = ctx.cur().unwrap();
         let mut tb = TagBuilder::new(&start_sym);
 
@@ -258,14 +258,14 @@ impl Parser {
                     tb.set_name( name_sym );
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         "Unexpected symbol".to_string()
                     ));
                 }
             }
         } else {
-            return Err(CrimError::eos("tag type"));
+            return Err(DeepCrowError::eos("tag type"));
         }
 
         if tb.can_have_params() || tb.can_have_expr() {
@@ -281,7 +281,7 @@ impl Parser {
                     tb.set_end( &end_sym )?;
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *end_sym.start(),
                         format!("Unexpected symbol {:?} looking for end of tag.", end_sym.symbol())
                         ));
@@ -294,14 +294,14 @@ impl Parser {
         Ok(tb)
     }
 
-    fn parse_tag_set<'a>(&self, ctx: &mut Context<'a>, mut base: TagBuilder<'a>) -> CrimResult<TagBuilder<'a>> {
+    fn parse_tag_set<'a>(&self, ctx: &mut Context<'a>, mut base: TagBuilder<'a>) -> Result<TagBuilder<'a>> {
         if base.is_unary() {
             return Ok(base);
         }
 
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos(format!("close tag for {:?}", base.name()).as_str()));
+                return Err(DeepCrowError::eos(format!("close tag for {:?}", base.name()).as_str()));
             }
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Text(s) => {
@@ -326,7 +326,7 @@ impl Parser {
                                tb.is_name(base.name().unwrap().symbol()) {
                                    return Ok(base);
                             } else {
-                                return Err(CrimError::parse(
+                                return Err(DeepCrowError::parse(
                                     *tb.name().unwrap().start(),
                                     format!("Found {:?} looking for close of {:?}", tb.name().unwrap().symbol(), base.name().unwrap().symbol())
                                 ));
@@ -336,7 +336,7 @@ impl Parser {
                             base.add_child(Entry::TagBuilder(tb));
                         }
                         TagType::Unknown => {
-                            return Err(CrimError::broken(base.start_pos(), "Found unknown tag when looking for something else."));
+                            return Err(DeepCrowError::broken(base.start_pos(), "Found unknown tag when looking for something else."));
                         }
                     }
                 }
@@ -344,7 +344,7 @@ impl Parser {
                     return self.lex_error( &ctx.cur().unwrap() );
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         format!("Unexpected token: {:?}", ctx.cur().unwrap().symbol()),
                     ));
@@ -353,10 +353,10 @@ impl Parser {
         }
     }
 
-    fn parse_tag_params(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> CrimResult<()> {
+    fn parse_tag_params(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<()> {
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos("tag parameters"));
+                return Err(DeepCrowError::eos("tag parameters"));
             }
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Literal(s) => {
@@ -377,7 +377,7 @@ impl Parser {
         Ok(())
     }
 
-    fn parse_identifier(&self, ctx: &mut Context ) -> CrimResult<ParamValue> {
+    fn parse_identifier(&self, ctx: &mut Context ) -> Result<ParamValue> {
         let mut id = Identifier::new();
 
         if ctx.cur().is("identifier",|s| matches!( s, SymbolType::Sharp))? {
@@ -390,7 +390,7 @@ impl Parser {
                     id.push( IdentifierValue::Name(s.to_string()) );
                 }
             } else {
-                return Err(CrimError::parse( ctx.cur().unwrap().start().clone(), format!("Expeceted identifier, found {:?}", ctx.cur().unwrap().symbol() ) ) );
+                return Err(DeepCrowError::parse( ctx.cur().unwrap().start().clone(), format!("Expeceted identifier, found {:?}", ctx.cur().unwrap().symbol() ) ) );
             }
 
             if !ctx.next().is("identifier seperator",|s| *s == SymbolType::Period )? {
@@ -402,10 +402,10 @@ impl Parser {
         Ok(ParamValue::Identifier(id))
     }
     
-    fn parse_tag_props(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> CrimResult<()> {
+    fn parse_tag_props(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<()> {
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos("tag properties"));
+                return Err(DeepCrowError::eos("tag properties"));
             }
             if let SymbolType::Token(s) = ctx.cur().unwrap().symbol() {
                 if ctx.peek().is_some_and(|s|s.check_type(|t| matches!(t,SymbolType::Equals))) {
@@ -414,7 +414,7 @@ impl Parser {
                         let SymbolType::Literal(lv) = sym.symbol() {
                         tb.add_prop( s.to_string(), lv.to_string() );
                     } else {
-                        return Err(CrimError::parse(Position::none(),"Expected quoted literal string".to_string()));
+                        return Err(DeepCrowError::parse(Position::none(),"Expected quoted literal string".to_string()));
                     }
                 } else {
                     break;
@@ -447,8 +447,8 @@ type EntryList<'a> = Vec<Entry<'a>>;
 
 trait EntryListConverter {
     fn has_outputs(&self) -> bool;
-    fn to_outputs(&mut self, ctx: &mut Context ) -> CrimResult<Vec<Output>>;
-    fn to_tokens(&mut self, ctx: &mut Context) -> CrimResult<Vec<Token>>;
+    fn to_outputs(&mut self, ctx: &mut Context ) -> Result<Vec<Output>>;
+    fn to_tokens(&mut self, ctx: &mut Context) -> Result<Vec<Token>>;
 }
 
 impl<'a> EntryListConverter for EntryList<'a> {
@@ -463,7 +463,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
             )
     }
 
-    fn to_outputs(&mut self, ctx: &mut Context) -> CrimResult<Vec<Output>> {
+    fn to_outputs(&mut self, ctx: &mut Context) -> Result<Vec<Output>> {
         let mut outputs = Vec::new();
             
         if self.has_outputs() {
@@ -489,7 +489,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
         Ok(outputs)
     }
 
-    fn to_tokens(&mut self, ctx: &mut Context) -> CrimResult<Vec<Token>> {
+    fn to_tokens(&mut self, ctx: &mut Context) -> Result<Vec<Token>> {
         let mut tokens : Vec<Token> = Vec::new();
         for e in self.drain(..) {
             match e {
@@ -500,7 +500,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
                     if let BuildResult::Token(token) = tb.build(ctx)? {
                         tokens.push( token );
                     } else {
-                        return Err(CrimError::broken( Position::none(), "Non-token result built."));
+                        return Err(DeepCrowError::broken( Position::none(), "Non-token result built."));
                     }
                 }
             }
@@ -545,14 +545,14 @@ impl<'a> TagBuilder<'a> {
         }
     }
 
-    pub fn set_end(&mut self, end: &Symbol) -> CrimResult<()> {
+    pub fn set_end(&mut self, end: &Symbol) -> Result<()> {
         if *self.start.symbol() == SymbolType::StartFlat {
             if *end.symbol() == SymbolType::EndFlat {
                 self.tag_type = TagType::Unary;
             } else if *end.symbol() == SymbolType::EndPoint {
                 self.tag_type = TagType::MultinaryOpen;
             } else {
-                return Err(CrimError::broken( *end.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *end.start(), "Invalid bracket token type."));
             }
         } else if *self.start.symbol() == SymbolType::StartPoint {
             if *end.symbol() == SymbolType::EndFlat {
@@ -560,10 +560,10 @@ impl<'a> TagBuilder<'a> {
             } else if *end.symbol() == SymbolType::EndPoint {
                 self.tag_type = TagType::MultinaryMid;
             } else {
-                return Err(CrimError::broken( *end.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *end.start(), "Invalid bracket token type."));
             }
         } else {
-                return Err(CrimError::broken( *self.start.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *self.start.start(), "Invalid bracket token type."));
         }
         Ok(())
     }
@@ -659,14 +659,14 @@ impl<'a> TagBuilder<'a> {
         self.tag_type
     }
 
-    pub fn build(mut self, ctx: &mut Context ) -> CrimResult<BuildResult> {
+    pub fn build(mut self, ctx: &mut Context ) -> Result<BuildResult> {
         if let Some(sym) = self.name {
             match sym.symbol() {
                 SymbolType::View => {
                     let name = if let ParamValue::Literal(s) = self.params.swap_remove(0) {
                         s.to_string()
                     } else {
-                        return Err(CrimError::parse(Position::none(), "Expected string literal for view name.".to_string()));
+                        return Err(DeepCrowError::parse(Position::none(), "Expected string literal for view name.".to_string()));
                     };
                     Ok(BuildResult::View(View {
                         name: name,
@@ -680,7 +680,7 @@ impl<'a> TagBuilder<'a> {
                     let name = if let ParamValue::Literal(s) = self.params.swap_remove(0) {
                         s.to_string()
                     } else {
-                        return Err(CrimError::parse(Position::none(), "Expected string literal for output name.".into()));
+                        return Err(DeepCrowError::parse(Position::none(), "Expected string literal for output name.".into()));
                     };
                     Ok(BuildResult::Output(Output {
                         name: name,
@@ -692,7 +692,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for loop variable name.".into())
                             );
@@ -706,7 +706,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for show variable name.".into())
                             );
@@ -718,7 +718,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for if variable name.".into())
                             );
@@ -744,7 +744,7 @@ impl<'a> TagBuilder<'a> {
                     let id = if let ParamValue::Identifier(id) = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for elif variable name.".into())
                             );
@@ -775,11 +775,11 @@ impl<'a> TagBuilder<'a> {
                     Ok(BuildResult::Token(Token::If(Identifier::new(), self.children.to_tokens(ctx)?, self.chain.to_tokens(ctx)?)))
                 }
                 _ => {
-                    Err(CrimError::parse( self.start_pos(), "Bad tag type".into()))
+                    Err(DeepCrowError::parse( self.start_pos(), "Bad tag type".into()))
                 }
             }
         } else {
-            Err(CrimError::parse(self.start_pos(), "Bad tag type".into()))
+            Err(DeepCrowError::parse(self.start_pos(), "Bad tag type".into()))
         }
     }
 }
diff --git a/crimtag/src/position.rs b/deepcrow/src/position.rs
index 24f5309..24f5309 100644
--- a/crimtag/src/position.rs
+++ b/deepcrow/src/position.rs