continuing work on building a better test tree.

TODO have the iterator return a block ID and its indentation level.
this will facilitate actually rendering the block content properly.

Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "outline-rs"
+version = "0.1.0"

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "outline-rs"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+
+[lib]
+

README.md

@@ -1,2 +1,16 @@
-# outline-rs
+# Outline-rs
 
+lightweight relational database-backed personal knowledge management outliner
+
+*Very* under construction!
+
+## Motivation
+
+Two PKM apps I've tried use Electron frontends, and I want a library that can
+back different frontends depending on the environment. I have been
+using a low-power ARM laptop recently and I can't be running a whole browser
+engine just to take notes.
+Also, containing all note data in a database will allow for extending with
+sync servers as a first-class experience rather than an afterthought.
+
+Using this as a project to learn rust as I go.

src/blocktree.rs

@@ -0,0 +1,163 @@
+
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct NoteBlock {
+    // IDs are int64 as this is the datatype of rowids in sqlite
+    id: i128,
+    pub first_child_id: Option<i128>,
+    pub next_sibling_id: Option<i128>,
+    
+    content: String
+}
+
+impl NoteBlock {
+    pub fn new(id: i128, first_child_id: Option<i128>, next_sibling_id: Option<i128>, content: String) -> Self {
+        Self {id, first_child_id, next_sibling_id, content}
+    }
+}
+
+#[derive(Debug)]
+pub struct BlockTreeNode {
+    // a tree of nodes, where each node refers to its block by id.
+    // the id is used as the key in a page's block table.
+    block_id: i128,
+    block_level: Option<usize>,
+    first_child_node: Option<Box<BlockTreeNode>>,
+    next_sibling_node: Option<Box<BlockTreeNode>>
+}
+
+impl BlockTreeNode {
+    fn new(block_id: i128) -> Self {
+        BlockTreeNode {
+            block_id,
+            block_level: None,
+            first_child_node: None,
+            next_sibling_node: None
+        }
+    }
+}
+
+pub struct BlockTreeIterator<'a> {
+    node_stack: Vec<&'a BlockTreeNode>
+}
+
+impl<'a> BlockTreeIterator<'a> {
+    pub fn new(root_node: &'a BlockTreeNode) -> Self {
+        Self {
+            node_stack: vec![root_node]
+        }
+    }
+}
+
+impl<'a> Iterator for BlockTreeIterator<'a> {
+    type Item = i128;
+    fn next(&mut self) -> Option<Self::Item> {
+
+        // stack is empty, we are done otherwise continue with current_node
+        let Some(current_node) = self.node_stack.pop() else {
+            return None;
+        };
+
+        // if the current node has a next sibling, stack it.
+        if let Some(next_sibling_node) = &current_node.next_sibling_node {
+            self.node_stack.push(next_sibling_node);
+        }
+
+        // if the current node has a first child, stack it.
+        if let Some(first_child_node) = &current_node.first_child_node {
+            self.node_stack.push(first_child_node);
+        }
+
+        // yield a clone of the block pointed to by current_node
+        Some(current_node.block_id)
+    }
+}
+
+#[derive(Debug)]
+pub struct NotePage {
+    title: String,
+    id: i128,
+    pub block_tree_root: BlockTreeNode,
+    
+    block_table: HashMap<i128, NoteBlock>
+}
+
+impl NotePage {
+    pub fn new(title: String, id: i128, root_block: NoteBlock) -> Self {
+        let mut new_page = Self {
+            title, 
+            id, 
+            block_tree_root: BlockTreeNode::new(root_block.id),
+            block_table: HashMap::new()
+        };
+        new_page.block_tree_root.block_level = Some(0);
+        new_page.block_table.insert(root_block.id, root_block);
+        new_page
+    }
+    
+    pub fn insert(self: &mut Self, block: NoteBlock) {
+        self.block_table.insert(block.id, block);
+    }
+    
+    pub fn build_tree(self: &mut Self) {
+        let mut node_stack = Vec::new();
+        node_stack.push(&mut self.block_tree_root);
+        while !node_stack.is_empty() {
+            println!("{:?}", node_stack);
+            let current_node = node_stack.pop().unwrap();
+            let current_block = self.block_table.get(&current_node.block_id).unwrap();
+            if let Some(next_sibling_id) = current_block.next_sibling_id {
+                let mut sibling_node = BlockTreeNode::new(next_sibling_id);
+                sibling_node.block_level = current_node.block_level;
+                current_node.next_sibling_node = Some(Box::new(sibling_node));
+                node_stack.push(current_node.next_sibling_node.as_mut().unwrap());
+            }
+            if let Some(first_child_id) = current_block.first_child_id {
+                let mut child_node = BlockTreeNode::new(first_child_id);
+                child_node.block_level = Some(current_node.block_level.unwrap() + 1);
+                current_node.first_child_node = Some(Box::new(child_node));
+                node_stack.push(current_node.first_child_node.as_mut().unwrap());
+            }
+        }
+    }
+}
+
+struct NotePageIterator<'a> {
+    page: &'a NotePage,
+    node_stack: Vec<&'a BlockTreeNode>
+}
+
+impl<'a> NotePageIterator<'a> {
+    fn new(page: &'a NotePage) -> Self {
+        Self {
+            page: page,
+            node_stack: vec![&page.block_tree_root]
+        }
+    }
+}
+
+impl<'a> Iterator for NotePageIterator<'a> {
+    type Item = NoteBlock;
+    fn next(&mut self) -> Option<Self::Item> {
+
+        // stack is empty, we are done otherwise continue with current_node
+        let Some(current_node) = self.node_stack.pop() else {
+            return None;
+        };
+
+        // if the current node has a next sibling, stack it.
+        if let Some(next_sibling_node) = &current_node.next_sibling_node {
+            self.node_stack.push(next_sibling_node);
+        }
+
+        // if the current node has a first child, stack it.
+        if let Some(first_child_node) = &current_node.first_child_node {
+            self.node_stack.push(first_child_node);
+        }
+
+        // yield a clone of the block pointed to by current_node
+        Some(self.page.block_table.get(&current_node.block_id).unwrap().clone())
+    }
+
+}

src/lib.rs

@@ -0,0 +1 @@
+pub mod blocktree;

src/main.rs

@@ -0,0 +1,44 @@
+use std::collections::HashMap;
+
+use outline_rs::blocktree::{NoteBlock, NotePage, BlockTreeIterator};
+
+fn main() {
+    let root_block = NoteBlock::new(0,Some(1),None,String::from("hello"));
+
+    let mut block_map = HashMap::new();
+    for idx in 1..=5 {
+        let new_block = NoteBlock::new(idx,None, None, String::from("I'm block {idx}"));
+        block_map.insert(idx,new_block);
+    }
+
+    let mut page = NotePage::new(String::from("page 1"), 0, root_block);
+
+    // take each new block and give it some children/siblings
+    let mut block1 = block_map.remove(&1).unwrap();
+    block1.next_sibling_id = Some(2);
+    page.insert(block1);
+
+    let mut block2 = block_map.remove(&2).unwrap();
+    block2.first_child_id = Some(3);
+    block2.next_sibling_id = Some(4);
+    page.insert(block2);
+
+    let mut block3 = block_map.remove(&3).unwrap();
+    page.insert(block3);
+
+    let mut block4 = block_map.remove(&4).unwrap();
+    block4.first_child_id = Some(5);
+    page.insert(block4);
+
+    let mut block5 = block_map.remove(&5).unwrap();
+    page.insert(block5);
+
+    page.build_tree();
+
+    println!("{:?}", page);
+//    println!("{:?}", page.block_tree_root.first_child_node)
+    let iter = BlockTreeIterator::new(&page.block_tree_root);
+    for id in iter {
+        println!("{}", id);
+    }
+}