It works! Lots to do, but it works.

We have a lot of cleanup to do, remove debugging prints, and make it
easier to use other structures and complex variable references, etc.

1 files changed, 20 insertions, 11 deletions

diff --git a/src/parser.rs b/src/parser.rs
index 1591c8b..aff64f6 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -10,6 +10,15 @@ pub struct ParseError {
     what: String,
 }
 
+impl ParseError {
+    pub fn new( position: Position, what: &str ) -> Self {
+        ParseError {
+            position,
+            what: what.to_string(),
+        }
+    }
+}
+
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Error parsing input: {}", "yeah")
@@ -85,7 +94,7 @@ impl<'a> SymbolHelper for Option<Symbol<'a>> {
         if let Some(st) = self {
             Ok(match st.symbol() {
                 SymbolType::Token(_) |
-                SymbolType::Fragment |
+                SymbolType::View |
                 SymbolType::Output |
                 SymbolType::Show => true,
                 _ => false
@@ -127,7 +136,7 @@ pub struct Parser {
  * close_tag: '<|' token '|]'
  *          ;
  *
- * tag_guts: 'fragment' literal props
+ * tag_guts: 'view' literal props
  *         | 'section' literal
  *         | 'output' literal
  *         ;
@@ -167,7 +176,7 @@ pub struct Parser {
  * close_tag: '<|' token '|]'
  *          ;
  *
- * tag_guts: 'fragment' literal props
+ * tag_guts: 'view' literal props
  *         | 'section' literal
  *         | 'output' literal
  *         ;
@@ -216,7 +225,7 @@ impl Parser {
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Text(_) => { /* Skip top level text */ }
                 SymbolType::StartFlat => {
-                    children.push( self.parse_tag_fragment( ctx )? );
+                    children.push( self.parse_tag_view( ctx )? );
                 }
                 SymbolType::Error{..} => {
                     return self.lex_error( &ctx.cur().unwrap() );
@@ -230,9 +239,9 @@ impl Parser {
         Ok(Token::Root(children))
     }
 
-    fn parse_tag_fragment(&self, ctx: &mut Context) -> ParseResult<Token> {
+    fn parse_tag_view(&self, ctx: &mut Context) -> ParseResult<Token> {
         let mut tb = self.parse_open_tag( ctx )?;
-        if !tb.is_name( &SymbolType::Fragment ) {
+        if !tb.is_name( &SymbolType::View ) {
             return Err(ParseError{
                 position: tb.start_pos(),
                 what: "Unexpected tag type, only frament allowed at root".to_string(),
@@ -244,7 +253,7 @@ impl Parser {
         }
         let mut children = Vec::new();
 
-        println!("--parse-tag-fragment-- tag parsed, next token: {:?}", ctx.cur() );
+        println!("--parse-tag-view-- tag parsed, next token: {:?}", ctx.cur() );
         loop {
             if ctx.cur().is_none() {
                 return Err(ParseError{
@@ -328,7 +337,7 @@ impl Parser {
 
         if ctx.next().is_some() {
             match ctx.cur().unwrap().symbol() {
-                SymbolType::Fragment | SymbolType::Show |
+                SymbolType::View | SymbolType::Show |
                 SymbolType::Output => {
                     let name_sym = ctx.cur().unwrap();
                     ctx.next();
@@ -532,7 +541,7 @@ impl<'a> TagBuilder<'a> {
         }
     }
 
-    pub fn name(&self) -> Option<Symbol> {
+    pub fn name(&self) -> Option<Symbol<'a>> {
         self.name
     }
 
@@ -570,8 +579,8 @@ impl<'a> TagBuilder<'a> {
     pub fn build(mut self) -> ParseResult<Token> {
         if let Some(sym) = self.name {
             match sym.symbol() {
-                SymbolType::Fragment => {
-                    Ok(Token::Fragment(self.params.swap_remove(0), self.props, self.children))
+                SymbolType::View => {
+                    Ok(Token::View(self.params.swap_remove(0), self.props, self.children))
                 }
                 SymbolType::Output => {
                     Ok(Token::Output(self.params.swap_remove(0), self.props, self.children))