It parses correctly for everything defined.

I think I'll change fragment to view, it's nicer and shorter.

1 files changed, 206 insertions, 30 deletions

diff --git a/src/parser.rs b/src/parser.rs
index 368a246..1591c8b 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -51,12 +51,45 @@ impl<'a> Context<'a> {
     pub fn peek(&self) -> Option<Symbol<'a>> {
         self.cur[(self.icur+1)%2]
     }
+
+    pub fn check_unwrapped<T: Fn( &SymbolType, &SymbolType ) -> bool>(&self, f: T) -> ParseResult<bool> {
+        if self.cur().is_none() || self.peek().is_none() {
+            Err(ParseError{
+                position: Position::new(0,0),
+                what: "Unexpected end of stream.".to_string()
+            })
+        } else  {
+            Ok(f( self.cur().unwrap().symbol(), self.peek().unwrap().symbol()))
+        }
+    }
+}
+
+trait SymbolHelper {
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, f: T ) -> ParseResult<bool>;
+    fn is_valid_tag_name(&self) -> ParseResult<bool>;
 }
 
-impl Option<Symbol> {
-    pub fn is<T: Fn( &SymbolType ) -> bool>(&self, f: T ) -> ParseError<bool> {
+impl<'a> SymbolHelper for Option<Symbol<'a>> {
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, f: T ) -> ParseResult<bool> {
+        if let Some(st) = self {
+            Ok(f( &st.symbol() ))
+        } else {
+            Err(ParseError{
+                position: Position::new(0,0),
+                what: "Unexpected end of stream.".to_string()
+            })
+        }
+    }
+    
+    fn is_valid_tag_name(&self) -> ParseResult<bool> {
         if let Some(st) = self {
-            Ok(f( &self.symbol ))
+            Ok(match st.symbol() {
+                SymbolType::Token(_) |
+                SymbolType::Fragment |
+                SymbolType::Output |
+                SymbolType::Show => true,
+                _ => false
+            })
         } else {
             Err(ParseError{
                 position: Position::new(0,0),
@@ -166,15 +199,15 @@ impl Parser {
         }
     }
 
-    pub fn parse(&mut self, src: &str ) -> ParseResult<Token> {
-        let mut ll = Lexer::new( src );
+    pub fn parse(&self, src: &str ) -> ParseResult<Token> {
+        let ll = Lexer::new( src );
         let mut ctx = Context::new( ll );
 
         // Parse the root of the file, the input context
         self.p_input( &mut ctx )
     }
 
-    fn p_input(&mut self, ctx: &mut Context ) -> ParseResult<Token> {
+    fn p_input(&self, ctx: &mut Context ) -> ParseResult<Token> {
         let mut children = Vec::new();
         loop {
             if ctx.cur().is_none() {
@@ -183,7 +216,7 @@ impl Parser {
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Text(_) => { /* Skip top level text */ }
                 SymbolType::StartFlat => {
-                    children.push( self.parse_tag( ctx )? );
+                    children.push( self.parse_tag_fragment( ctx )? );
                 }
                 SymbolType::Error{..} => {
                     return self.lex_error( &ctx.cur().unwrap() );
@@ -197,12 +230,99 @@ impl Parser {
         Ok(Token::Root(children))
     }
 
-    fn parse_tag(&mut self, ctx: &mut Context) -> ParseResult<TagBuilder> {
-        let mut tb = TagBuilder::new();
+    fn parse_tag_fragment(&self, ctx: &mut Context) -> ParseResult<Token> {
+        let mut tb = self.parse_open_tag( ctx )?;
+        if !tb.is_name( &SymbolType::Fragment ) {
+            return Err(ParseError{
+                position: tb.start_pos(),
+                what: "Unexpected tag type, only frament allowed at root".to_string(),
+            });
+        }
+
+        if tb.is_unary() {
+            return tb.build();
+        }
+        let mut children = Vec::new();
+
+        println!("--parse-tag-fragment-- tag parsed, next token: {:?}", ctx.cur() );
+        loop {
+            if ctx.cur().is_none() {
+                return Err(ParseError{
+                    position: Position::new(0,0),
+                    what: "Unexpected end of stream.".to_string()
+                });
+            }
+            match ctx.cur().unwrap().symbol() {
+                SymbolType::Text(s) => {
+                    children.push( Token::Text(s.to_string()) );
+                    ctx.next();
+                }
+                SymbolType::StartFlat => {
+                    //child.is_name(SymbolType::Output)
+                    children.push( self.parse_tag_body( ctx )? );
+                }
+                SymbolType::StartPoint => {
+                    let end = self.parse_end_tag( ctx )?;
+                    println!("End tag: {:?}, open tag: {:?}", end, tb.name() );
+                    if tb.is_name(end.symbol()) {
+                        // They match, time to decide what we're doing.
+                        let any_outputs = children.iter().any(
+                            |t| matches!(t, Token::Output(..))
+                            );
+                        if children.iter().all(|t| matches!(t, Token::Text(..)) || matches!(t, Token::Output(..))) {
+                            // Everything is either text or output
+                            if !any_outputs {
+                                // Special case, if it's only text then we create an implicit output.
+                                tb.add_child(Token::Output("content".to_string(), Properties::new(), children ));
+                            }
+                            else {
+                                // Standard case, outputs are included, text is
+                                // skipped.
+                                for token in children {
+                                    if matches!(token, Token::Output(..)) {
+                                        tb.add_child( token );
+                                    }
+                                }
+                            }
+                        } else {
+                            // We have another mix, now check to see if there
+                            // are any outptus, if so this is an error.
+                            if any_outputs {
+                                return Err(ParseError{
+                                    position: *end.start(),
+                                    what: "You cannot mix non-output and output tags in a view.".to_string()
+                                });
+                            } else {
+                                // No outputs at all, we create an implict output
+                                tb.add_child(Token::Output("content".to_string(), Properties::new(), children ));
+                            }
+                        }
+
+                        return tb.build();
+                    } else {
+                        // They don't match, complain.
+                        return Err(ParseError{
+                            position: *end.start(),
+                            what: "Mismatched open and closing tags.".to_string()
+                        });
+                    }
+                }
+                SymbolType::Error{..} => {
+                    return self.lex_error( &ctx.cur().unwrap() );
+                }
+                _ => {
+                    ctx.next();
+                }
+            }
+        }
+    }
+
+    fn parse_open_tag<'a>(&self, ctx: &mut Context<'a>) -> ParseResult<TagBuilder<'a>> {
         
         println!("--> Begin parse_tag <--");
 
         let start_sym = ctx.cur().unwrap();
+        let mut tb = TagBuilder::new(&start_sym);
 
         println!("--> Start sym: {:?}", start_sym );
 
@@ -239,19 +359,40 @@ impl Parser {
             }
         }
 
+        ctx.next();
+
         Ok(tb)
     }
 
-    fn parse_end_tag(&mut self, ctx: &mut Context ) -> &'a str {
-        if !ctx.cur().is(|s| matches!(s, Symbol::StartPoint))? {
+    fn parse_end_tag<'a>(&self, ctx: &mut Context<'a> ) -> ParseResult<Symbol<'a>> {
+        if !ctx.cur().is(|s| *s == SymbolType::StartPoint )? {
+            return Err(ParseError{
+                position: *ctx.cur().unwrap().start(),
+                what: "Invalid end tag?".to_string(),
+            });
+        }
+        if !ctx.next().is_valid_tag_name()? {
+            return Err(ParseError{
+                position: *ctx.cur().unwrap().start(),
+                what: "Invalid tag name".to_string(),
+            });
+        }
+        let name = ctx.cur().unwrap();
+        if !ctx.next().is(|s| *s == SymbolType::EndFlat )? {
             return Err(ParseError{
-                position: ctx.cur().
+                position: *ctx.cur().unwrap().start(),
+                what: "Tag should be <| |] style end tag.".to_string(),
             });
         }
-            ctx.next()
+        Ok(name)
     }
 
-    fn parse_tag_body(&mut self, ctx: &mut Context, tb: &mut TagBuilder ) -> ParseResult<()> {
+    fn parse_tag_body(&self, ctx: &mut Context ) -> ParseResult<Token> {
+        let mut tb = self.parse_open_tag( ctx )?;
+        if tb.is_unary() {
+            return tb.build();
+        }
+
         loop {
             if ctx.cur().is_none() {
                 return Err(ParseError{position: Position::new(0,0), what: "Unexpecetd end of stream".to_string()});
@@ -259,28 +400,37 @@ impl Parser {
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Text(s) => {
                     tb.add_child(Token:: Text(s.to_string()));
+                    ctx.next();
                 }
                 SymbolType::StartFlat => {
-                    tb.add_child( self.parse_tag( ctx )? );
+                    tb.add_child( self.parse_tag_body( ctx )? );
+                    println!("Following tag body: {:?} {:?}", ctx.cur(), ctx.peek() );
                 }
                 SymbolType::StartPoint => {
-                    let end_tag = self.parse_end_tag( ctx )?;
-
+                    let end = self.parse_end_tag( ctx )?;
+                    println!("End tag: {:?}, open tag: {:?}", end, tb.name() );
+                    if tb.is_name(end.symbol()) {
+                        // They match, end.
+                        return tb.build();
+                    } else {
+                        // They don't match, complain.
+                        return Err(ParseError{
+                            position: *end.start(),
+                            what: "Mismatched open and closing tags.".to_string()
+                        });
+                    }
                 }
                 SymbolType::Error{..} => {
-                    return self.lex_error( &ctx.cur().unwrap() );
+                    self.lex_error( &ctx.cur().unwrap() )?;
                 }
                 _ => {
 
                 }
             }
-            ctx.next();
         }
-        Ok(Token::Root(children))
-        Ok(())
     }
 
-    fn parse_tag_params(&mut self, ctx: &mut Context, tb: &mut TagBuilder ) -> ParseResult<()> {
+    fn parse_tag_params(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> ParseResult<()> {
         loop {
             if ctx.cur().is_none() {
 
@@ -299,7 +449,7 @@ impl Parser {
         Ok(())
     }
     
-    fn parse_tag_props(&mut self, ctx: &mut Context, tb: &mut TagBuilder ) -> ParseResult<()> {
+    fn parse_tag_props(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> ParseResult<()> {
         loop {
             if ctx.cur().is_none() {
                 return Err(ParseError{position: Position::new(0,0), what: "Unexpecetd end of stream".to_string()});
@@ -325,7 +475,7 @@ impl Parser {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq,Copy,Clone,Debug)]
 enum TagType {
     Unknown,
     Unary,
@@ -339,20 +489,34 @@ struct TagBuilder<'a> {
     props: Properties,
     children: Vec<Token>,
     tag_type: TagType,
+    start_pos: Position,
 }
 
 impl<'a> TagBuilder<'a> {
-    pub fn new() -> TagBuilder<'a> {
+    pub fn new(start: &Symbol) -> TagBuilder<'a> {
         TagBuilder {
             name: None,
             params: Vec::new(),
             props: Properties::new(),
             children: Vec::new(),
             tag_type: TagType::Unknown,
+            start_pos: *start.start(),
         }
     }
 
-    pub fn has_children(&self) -> bool {
+    pub fn start_pos(&self) -> Position {
+        self.start_pos
+    }
+
+    pub fn is_unary(&self) -> bool {
+        if self.tag_type == TagType::Unary {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn can_have_children(&self) -> bool {
         if self.tag_type == TagType::BinaryOpen {
             true
         } else {
@@ -360,14 +524,18 @@ impl<'a> TagBuilder<'a> {
         }
     }
 
-    pub fn is_same_name(&self, name: Symbol<'a>) -> bool {
+    pub fn is_name(&self, name: &SymbolType<'a>) -> bool {
         if let Some(a) = self.name {
-            a.symbol() == name.symbol()
+            a.symbol() == name
         } else {
             false
         }
     }
 
+    pub fn name(&self) -> Option<Symbol> {
+        self.name
+    }
+
     pub fn set_name(&mut self, name: Symbol<'a>) {
         self.name = Some(name);
         println!("Tag name: {:?}", self.name );
@@ -387,10 +555,18 @@ impl<'a> TagBuilder<'a> {
         self.children.push( token );
     }
 
+    pub fn append_children(&mut self, children: &mut Vec::<Token>) {
+        self.children.append( children );
+    }
+
     pub fn set_type(&mut self, tag_type: TagType) {
         self.tag_type = tag_type;
     }
 
+    pub fn tag_type(&self) -> TagType {
+        self.tag_type
+    }
+
     pub fn build(mut self) -> ParseResult<Token> {
         if let Some(sym) = self.name {
             match sym.symbol() {
@@ -406,14 +582,14 @@ impl<'a> TagBuilder<'a> {
                 _ => {
                     println!("Unkown tag type");
                     Err(ParseError {
-                        position: Position::new(0,0),
+                        position: self.start_pos,
                         what: "Bad tag type".to_string(),
                     })
                 }
             }
         } else {
                     Err(ParseError {
-                        position: Position::new(0,0),
+                        position: self.start_pos,
                         what: "Bad tag type".to_string(),
                     })
         }