parse through containers (temporary solution)

src/lib.rs

@@ -18,7 +18,7 @@ pub enum Content {
 }
 
 pub fn parse_content(c: &str) -> Vec<Content>{
-    process_content(itemize_content(c)).into_iter().map(|i| {
+    process_content(&itemize_content(c)).into_iter().map(|i| {
         match i {
             Content::Markdown(s) => {
                 Content::MarkdownParsed(markdown::parse(&s).collect())
@@ -151,10 +151,10 @@ fn media_content(item: &Item) -> Content{
 }
 
 
-fn process_content(items: Vec<Item>) -> Vec<Content> {
+fn process_content(items: &Vec<Item>) -> Vec<Content> {
     let mut result: Vec<Content> = Vec::new();
     //println!("Converting {} items into Content",items.len());
-    for i in &items {
+    for i in items {
         match i {
             Item::Title(_,_) => {
                 result.push(markdown_content(i));
@@ -192,6 +192,12 @@ fn process_content(items: Vec<Item>) -> Vec<Content> {
             Item::Audio(_) => {
                 result.push(media_content(i));
             }
+            Item::Container(children) => {
+                //should actually plan to contain things
+                for c in process_content(children){
+                    result.push(c);
+                }
+            }
             _ => {
                 result.push(Content::Ignore);
             }
@@ -218,7 +224,8 @@ enum Item {
     UnorderedList(Vec<Item>),
     OrderedList(Vec<Item>),
     ListItem(Vec<Item>),
-    Paragraph(Vec<Item>),//gotta replace this with specific items, needlessly flexible
+    Paragraph(Vec<Item>),
+    Container(Vec<Item>),
     Link(String,Vec<Item>),
     Table(Vec<Item>)
 }
@@ -293,6 +300,9 @@ fn parse_items(n: ego_tree::NodeRef<'_,Node>) -> Item{
             "li" => {
                 return Item::ListItem(get_children(&el))
             }
+            "div" => {
+                return Item::Container(get_children(&el))
+            }
 
             _ => {}
         };  

src/tests/mod.rs

@@ -11,7 +11,7 @@ fn fragments() {
     for f in FRAGMENTS {
         println!("Processing Fragment:{}",f);
         let items = itemize_content(f);
-        let content = process_content(items);
+        let content = process_content(&items);
         println!("Content:\n{:#?}",content);
     }
 }
@@ -20,15 +20,15 @@ fn fragments() {
 fn content_test() {
     let example_text = Item::Text("Example.com".to_owned());
     let example_link = Item::Link("https://example.com".to_owned(), [example_text].to_vec());
-    let result = process_content([example_link].to_vec());
+    let result = process_content(&[example_link].to_vec());
     println!("Items to content parse result:\n{:#?}", result);
 }
 
 #[test]
 fn content_display() {
     let feed = get_feed(example_data::GABE_ROCKS);
-    let content: Vec<_> = process_content(itemize_content(
-        feed.items.first().unwrap().content().unwrap(),
+    let content: &Vec<Content> = &process_content(&itemize_content(
+        feed.items.get(4).unwrap().content().unwrap(),
     ));
     println!("Content: {:#?}", content)
 }
@@ -59,7 +59,7 @@ fn markdownify_feeds() {
             .items
             .into_iter()
             .map(|item| {
-                process_content(itemize_content(&item.content.unwrap()));
+                process_content(&itemize_content(&item.content.unwrap()));
             })
             .collect();
         println!("Processed {} items without errors", results.len())